Data Processing

Data processing

Data

Data are normally defined as a representation of facts, concepts and instructions during a formalized manner with which it should be suitable for communication, interpretation, or processing by human or electronic machine.

Data is represented with the help of characters like alphabets (A-Z,a-z), digits (0-9) or special characters(+,-,/,*,,= etc.).

Raw Computer Data

What is Information?

Information is processed,organised or classified data which has some meaningful values for the receiver.

Information is that the processed data on which decisions and actions are based.

For the choice to be meaningful, the processed data must qualify for the subsequent characteristics:

 Timely - Information should be available when required.

 Accuracy - Information should be accurate.

 Completeness - Information should be complete.

Data Processing Cycle

Data processing is that the re-structuring or re-ordering of knowledge by people or machine to extend their usefulness and add values for particular purpose. Data processing has three basic steps include input, processing and output. These three steps constitute the data processing cycle.

Computer Data

 Input - during this step the input file is ready in some convenient form for processing. The form will depend on the processing machine. For example, when electronic computers are used, the input file might be recorded on anybody of several sorts of input medium, like magnetic disks, tapes then on.

Processing - during this step input file is modified to supply data during a more useful form. For example, pay-checks could also be calculated from the time cards, or a summary of sales for the month could also be calculated from the sales orders.

Output - The results of the processing steps are called output. The particular sort of the output data depends on the utilization of the info. For example, output data could also be pay-checks for workers.

Data types

Data types are generally used to within type systems, which supply various ways of defining, implementing and using them. Different types of data types in systems ensure that varying degrees of type safety.

Practically all programming dialects incorporate the thought of knowledge type; They have used different terminology in different languages. Common data types include:

 * integers,

 * booleans,

 * characters,

 * floating-point numbers,

 * alphanumeric strings.

For example, within the Java programming language, the "int" type represents the set of 32-bit integers ranging in value from -2,147,483,648 to 2,147,483,647, also because the operations which will be performed on integers, like addition, subtraction, and multiplication.

Most of the programming languages are also allowed the programmer to define additional data types, usually by combining multiple elements of other types and defining the valid operations of the new data type. For example, a programmer might create a replacement data type named "complex number" that might include real and imaginary parts. A data type also represents a constraint placed upon the interpretation of knowledge during a type system; it is describing the representation, interpretation and structure of values or objects stored in memory. The type system uses data type information to see correctness of computer programs that access or manipulate the information.

Most data types in statistics have comparable types in programming, and the other way around, as shown within the following table:

Statistics Programming

real-valued (interval scale) floating-point

real-valued (ratio scale)

count data (usually non-negative) integer

binary data Boolean

categorical data enumerated type

random vector list or array

random matrix two-dimensional array

random tree tree

The definition in terms of a representation was often wiped out imperative languages like ALGOL and Pascal, while the definition in terms of a worth space and behaviour was used in higher-level languages like Simula and CLU.

Classes of data types

Primitive data types

Main article: Primitive data type

Machine data types

All data in computers supported digital electronics is represented as bits (alternatives 0 and 1) on rock bottom level. The smallest addressable unit of knowledge is typically a gaggle of bits called a byte (usually an octet, which is 8 bits). The unit processed by machine language instructions is named a word (as of 2011, typically 32 or 64 bits). Most instructions have interpreted the word as a binary number, such that a 32-bit word which can represent unsigned integer values from 0 to 2³²-1 or signed integer values from -2³¹ to 2³¹-1. Because of two's complement, the machine language and machine doesn't have to distinguish between these unsigned and signed data types for the foremost part.

There is a selected set of arithmetic instructions that use a special interpretation of the bits in word as a number.

Machine data types got to be exposed or made available in systems or low-level programming languages, allowing fine-grained control over hardware. The C programming language, as an example, supplies integer sorts of various widths, like short and long. If a corresponding native type doesn't exist on the target platform, the compiler will break them down into code using types that do exist. For instance, if a 32-bit integer is requested on a 16 bit platform, the compiler will tacitly treat it as an array of two 16 bit integers.

Most of the languages have been using binary and hexadecimal literals, for convenient manipulation of machine data.

Higher level programming languages use machine data types which are abstracted as an implementation detail that might render code less portable if exposed. For instance, a generic numeric type could be supplied rather than integers of some specific bit-width.

Boolean type

The Boolean type is represented the values of true and false. Although only two values are possible, they're rarely implemented as one digit for efficiency reasons. Many programming languages don't have a particular Boolean type, instead interpreting (for instance) 0 as false and other values as true. Boolean data simply refers to the logical structure of how the language is interpreted to the machine language.  A Boolean 0 refers to the logic False. True is usually a non zero, especially 1 is understood as Boolean 1.

Numeric types

Such as:

* The integer data types, or "whole numbers". May be sub-typed consistent with their ability to contain negative values (e.g. unsigned in C and C++). May also have alittle number of predefined subtypes (such as short and long in C/C++); or allow users to freely define subranges like 1..12 (e.g. Pascal/Ada).

 * Floating point data types are called reals, contain fractional values. They have normally predefined limits on both their maximum values and their precision. These are often represented as decimal numbers.

 * Fixed point data types are conveniently used for representing monetary values. They are often implemented internally as integers, which is resulting in predefined limits.

 * Big numbers or arbitrary precision numeric types are lack of predefined limits. They are not primitive types, and they are used sparingly for efficiency reasons.

Composite types

Main article: Composite type

Composite types are derived from quite one primitive type. This can be wiped out variety of the way . The ways they're combined are called data structures. Composing a primitive type into a compound type generally leads to a replacement type, e.g. array-of-integer is a different type to integer.

 * An array stores variety of elements of an equivalent type during a specific order. They are accessed randomly using an integer to specify which element is required (although the weather could also be of just about any type). Arrays may be fixed-length or expandable.

 A list is analogous to an array, but its contents are strung together by a series of references to subsequent element.

 * Record (also called tuple or struct) Records are among the only data structures. A record may be a value that contains other values, typically in fixed number and sequence and typically indexed by names. The elements of records are usually called fields or members.

 * Union. A union type definition will specify which of variety of permitted primitive types could also be stored in its instances, e.g. "float or long integer". Contrast with a record, which might be defined to contain a float and an integer; whereas, during a union, there's just one value at a time.

 * A tagged union (also called a variant, variant record, discriminated union, or disjoint union) contains a further field indicating its current type, for enhanced type safety.

 * a group is an abstract arrangement which will store certain values, with none particular order, and no repeated values. Values themselves aren't retrieved from sets, rather one tests a worth for membership to get a boolean "in" or "not in".

 * An object contains variety of knowledge fields, sort of a record, and also variety of subroutines for accessing or modifying them, called methods. In contrast, data structures not containing code, like those above, are called plain old data structures.

Many others are possible, but they have a tendency to be further variations and compounds of the above.

Enumerations

Main article: Enumerated type

The enumerated type. This has values which are different from one another , and which may be compared and assigned, but which don't necessarily have any particular concretism within the computer's memory; compilers and interpreters can represent them arbitrarily. For example, the four suits during a deck of playing cards could also be four enumerators named CLUB, DIAMOND, HEART, SPADE, belonging to an enumerated type named suit. If a variable A is said to be its data type, one can assign any of these four values there. Some implementations allow programmers to assign integer values to the enumeration values, or maybe treat them as type-equivalent to integers.

String and text types

Such as:

 * Alphanumeric character. A letter of the alphabet, digit, space , punctuation , etc.

 * Alphanumeric strings, a sequence of characters. They are typically wont to represent words and text.

Character and string types can store sequences of characters from a personality set like ASCII. Since most character sets include the digits, it's possible to possess a numeric string, like "1234". However, many languages would still treat these as belonging to a special type to the numeric value 1234.

Character and string types can have different subtypes consistent with the specified character "width". The original 7-bit wide ASCII was found to be limited, and superseded by 8 and 16-bit sets, which may encode a good sort of non-Latin alphabets (Hebrew, Chinese) and other symbols. Strings could also be either stretch-to-fit or of fixed size, even within the same programing language . They may also be sub typed by their maximum size.

Note: strings aren't primitive altogether languages, as an example C: they'll be composed from arrays of characters.

Other types

Types are often supported , or derived from, the essential types explained above. In some languages, such as C, functions have a kind derived from the sort of their return value.

Pointers and references

The main non-composite, derived type is that the pointer, a knowledge type whose value refers on to (or "points to") another value stored elsewhere within the memory using its address. It is a primitive kind of reference. (In everyday terms, a pagination during a book might be considered a bit of knowledge that refers to a different one). Pointers are often stored during a format almost like an integer; however, attempting to dereference or "look up" a pointer whose value was never a legitimate memory address would cause a program to crash. To ameliorate this potential problem, pointers are considered a separate type to the sort of knowledge they point to, albeit the underlying representation is that the same.