Statistics

They are related but one might not be causing the other

difference is large

Statistics is the study and manipulation of data, including ways to gather, review, analyze, and draw conclusions from data. The two major areas of statistics are descriptive and inferential statistics.

There are a total of 36 outcomes. from 1,1; 1,2; .... to 6,5:6,6.

For these to total '7'

We have

1,6 ; 2,5 '; 3,4 ; 4,3 ; 5,2 ; & 6,1.

There are six outcomes.

So probability of a total of 7 ;

P(total 7) = 6/36 = 1/6

6215000

makeloude khali phirarain

A hypotheses becomes testable by actually doing the experiment and seeing what you find.

Decumbent stems are plant stems that initially grow upright but then curve downward and trail along the ground. They typically root at the nodes where they come in contact with the soil, allowing the plant to spread horizontally. Decumbent stems are often seen in trailing or creeping plants.

A variable data is anything that won't necessarily be the same every time you run a computer program. It may come from user input, from a random function, from consulting a database, etc.

Diatomic means consisting of two atoms. In chemistry, diatomic molecules are molecules composed of only two atoms of the same or different chemical elements bonded together. Examples include oxygen (O2) and hydrogen (H2).

Register variables are stored in register of microprocessor/micro-controller. The read/write access to register variable is the fastest because CPU never need any memory BUS operation to access these variable.

Auto variable are stored in stack thus access are much slower. Auto variable can be converted to register by using register keyword before it. It has platform specific limitation. Register variable will work only if free registers are available to hold the variable for a function scope. In case of Microprocessor or microcontrollers having very less number of general purpose registers will never take register variable even if we declare it as register.

a variable resistor is often called a control potentiometer ,

and would be used to supply a set voltage depending on the position of the wiper contact on the resistor assembly .

........

an example would be a speed control device on a motor , including battery drill drivers , a mini hand held drill tool for use in craft projects , a volume control slide/ positioner , which controls the amount of signal and hence the volmue at whic music is played on a music system throu speakers.

it could also be used in lighting control circuits , such as dimmer controls .

where it sets the level of light output by varying the applied volatge to the lamp

Indonesia has the greatest population threatened by a volcano, with more than 100 active volcanoes and over 17,000 islands prone to volcanic eruptions. The country is part of the Pacific Ring of Fire, a region known for its seismic and volcanic activity.

Macros are processed at preprocessing time where as constant variables are processed at complie time. Macros doesnot have any scope but constant variables has scope. Macros doesnot have the type checking where as constant variables have type checking.

Probability is related to inheritance because in Mendel's experiments, the probabilities were important. Each time Mendel repeated the cross, he observed that the principles of probability applied to his experiment.

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)

First, lets speak about the scope of a variable. The scope of a variable is the section of the application that can see and manipulate that variable. If the variable is declared in a procedure when that procedure is called, only that procedure can use that variable. Hence that variable is considered "Local".

Now Static. Static variables are variables that are created with the static key word as in:- function ab(var1 as integer)as integer static iTotal as integer itotal =iTotal + var1 (rest of ccode goes here) end function

Now when this function is called the first time, iTotal will be assigned the value of var1. The next time the function is called, iTotal will retain the previous value and the new value of var1 will be added to it. Hope this helps. (theTeacha)

Static variables life time is not under any scope.It initializes only one time from creation to delete.let me explain by a pgm.

void main()

{

int a=1;

static s=1;

int k=0;

for(k=0;k<1;k++)

{

i++;

s++;

main();

}

printf("%d is i",&i);

printf(%d is S",&s);

getch();

}

Output will be

2 is i

3 is s

It Shows that local variable initialize every time the function call.But Static variable initializes only once

<><><>

For a variable, static means it keeps its value even when the enclosing code is not active--out of scope. A static variable is assigned to a fixed memory location when the program runs, so it is possible to examine a static variable at any time the program is active, even when the function where the var is declared is not active. A local variable is dynamically allocated storage space when a function is called, and its storage is given up when the function ends, so it only exists while the function is executing.

For a function, static declaration means it can only be called from functions in the same file (in C).

Because in any real-world process, there is always uncertainty, and if you measure with enough precision you will always find variation in dimensions. Tolerances are specified so the machinist knows what is 'tolerable' and what is not acceptable. Assuming you are working in inches... A drawing dimension might be 1.50 +/- .03 . That would usually be a pretty easy tolerance to hit on a machined part. The machinist knows he doesn't need to be obsessive about this operation, and it will fit into where it is going as long as it is between 1.47 and 1.53 . He can measure it with a scale. Now, if it is 1.5000 +/.0001, it is much more difficult. The machinist needs to be very carefull here. He's going to need a good setup on good machinery, and something very precise to check the part with, in order to make a part that works. It is crucial that engineers and designers think about the tolerances they put on part drawings, because overly tight tolerances cost money, and overly loose tolerances might result in assemblies that don't work. Most of the time, the machinist does not know the context the part will be used in, so he/she shouldn't be left to make those decisions himself. When making parts on NC equipment right off CAD models, it is necessary to provide tolerance guidance to the machine shop to make sure the final part meets the need. Critical dimensions need to be identified at a minimum.

One bit is either a zero - 0, or a one - 1. Eight bits equal one byte. And one character is exactly one BYTE. So the letter A must be converted to a specific, universally recognized number (called ASCII) and then translated to binary code - 0s and 1s. So one 8-bit code equals one character.

Because all construction takes place in or on the ground, geotechnical engineering plays a crucial role in all civil engineering projects. The need to investigate the ground is of vital importance before any construction work takes place. The failure to carry out adequate site investigations often has had dramatic and expensive consequences on construction projects. Geotechnical engineers require a wide variety of skills and, in general, need to be smarter than other kinds of engineer. Whereas most engineers have the luxury of specifying the materials they use, the geotechnical engineer has no choice but to work with the natural soil and rock as he or she finds it. In a geotechnical consulting firm, everyone works in a team to complete a project. A team usually comprises a project director who oversees the whole project; a senior engineer, assisted by one or more engineers and geologists; a checker or checkers to make sure everything is done correctly; followed by an internal and an external reviewer.

A constant and variable are variations of data types.

int a;

is a variable and its value can be changed by the program as the program runs.

const int b;

is a constant with a fixed value and will have its value set and may not be changed by the program as as the program runs.

All data types may be declared as a constant.

Variable Value Can Be Changed By You In Programme.

You have to explicitly initialise all instance variables, otherwise their values will be initialised to whatever happens to be in memory at the time they are instantiated.

Consider the following class which has no explicit initialisation:

#include <iostream>

class object

{

public:

object(){}

public:

const int getData( void ) const { return( m_data ); }

private:

int m_data;

};

int main()

{

object O;

printf( "O.m_data = %d\n", O.getData() );

return( 0 );

}

Example output:

O.m_data = -858993460

This is not particularly useful; we must ensure m_data is initialised before we access its value.

One way to initialise object::m_data is from within the body of the constructor:

object(){ m_data = 0; } // inefficient initialisation

However this is quite inefficient because object::m_data will have already be instantiated by the time we got to the constructor body. This is akin to the following C-style initialisation:

int x; // instantiate x

x = 0; // initialise x

When what we really want to do is:

int x = 0;

Or use the more formal construction semantics:

int x(0);

Both achieve the same thing. They both initialise the variable x at the point of instantiation, not after instantiation. Fortunately, C++ allows us to initialise all instance variables at the point of instantiation, via the constructor's initialisation section:

object():m_data(0){} // efficient initialisation

While initialising a single primitive data type in the constructor body isn't going to cause major problems in terms of efficiency, with more complex data types the inefficiencies can very quickly add up. Thus it is important to use the initialisation section as much as possible and to only use the body of the constructor when there is no option.

The initialisation section is particularly important when dealing with derived classes. Consider the following:

#include <iostream>

class base

{

public:

base():m_int(0){}

base(const base& object):m_int(object.m_int){}

public:

const int getInt( void ) const { return( m_int ); }

void setInt( const int data ) { m_int = data; }

private:

int m_int;

};

class derived : public base

{

public:

derived():m_float(0.0){}

derived(const derived& object):m_float(object.m_float){}

public:

const float getFloat( void ) const { return( m_float ); }

void setFloat( const float data ) { m_float = data; }

private:

float m_float;

};

int main()

{

derived d;

d.setInt( 1 );

d.setFloat( 2.0 );

printf( "d.getInt() = %d, d.getFloat() = %f\n", d.getInt(), d.getFloat() );

derived c(d); // call copy constructor.

printf( "c.getInt() = %d, c.getFloat() = %f\n", c.getInt(), c.getFloat() );

return( 0 );

}

Example output:

d.getInt() = 1, d.getFloat() = 2.000000

c.getInt() = 0, c.getFloat() = 2.000000

Note that c should be an exact copy of d, but there's clearly a difference in the integer variables inherited from the base class. This is because the derived class copy constructor called the base class default constructor, not the base class copy constructor as you might have expected. To resolve this we must explicitly call the base class copy constructor and the only way to do so is via the initialisation section of the derived class:

derived(const derived& object):base(object),m_float(object.m_float){}

Note that the derived class' copy constructor now includes a call to base(object) in the initialisation section. This ensures the base class copy constructor is called. Although object is actually an instance of derived, because it derived from base it is also a kind of base, thus the call is legitimate. Now if we run the code we'll get the expected result:

d.getInt() = 1, d.getFloat() = 2.000000

c.getInt() = 1, c.getFloat() = 2.000000

As your classes become more and more complex you will inevitably find yourself creating overloaded constructors to provide a wide variety of initialisation methods. But keep in mind that it costs absolutely nothing to use the initialisation sections even if several constructors end up using the exact same initialisations. And while it is tempting to move all of the common initialisation code into a private method of the class and have each constructor call that method (known as a construction helper function), this simply adds yet more inefficiency by introducing yet another unnecessary function call. Helper functions such as these are undoubtedly useful during the initial development of a class but as soon as the class is finalised, get rid of the helper function and move all that functionality into the initialisation sections where they belong. In the case of derived classes, base class constructors will be called whether you like it or not, so it makes sense to call the most appropriate base class constructor from within the initialisation section of each of your derived class constructors. Remember that if you do not specify a base class constructor, its default constructor will be called implicitly, which may or may not be the most appropriate constructor in all cases (not least in the case of the copy constructor).

The main difference between the class variable and Instance variable is,

first time, when class is loaded in to memory, then only memory is allocated for all class variables. Usually static variables are called class variables. These variables are available throughout the execution of the application and the values are common to the class. You can access them directly without creating an object of the class.

Instance variables are normal variables declared in a class, that would get initialized when you create an instance of the class. Every instance of the class would have a copy of the variable and you need a class instance (object) to access these variables