## computer graphics Line Drawing Algorithm

Line Drawing is done by calculating Intermediate positions along the line path Between specified paths. DDA LINE Algorithm is a simplest algorithm of drawing a line . In DDA Algorithm line is simply Draws by adding the increment to initial pixel values with respect to x and y direction . After drawing initial pixel whose x and y direction are entered by user or inputted by user Then the Next pixel is drawn by adding Change in x and y direction of new pixel to the initial pixel

We will add the value of change in x and y axis to initial or previous x and y axis values to get New pixel plotted on screen and This process continues upto and end point that is also inputted by user at start of execution of This Algorithm

The Screen Locations are refrenced by integer values and if these values are in fraction like 10.25 and 21.4 :- (10.25,21.4)  where 10.25 is x coordinate in x-Axis and 21.4 is Y Coordinate in Y-Axis Then These Fractional Values will be converted into Integer values on Screen and interpreted as (10,21). This rounding of two integers cause lines to be displayed with stare steps appearance in Zagged line

### To Display a pixel on Screen we use

putpixel ( 10 , 11 )

How Line Drawn in DDA Line Algorithm

1. First user input the four values

* Initial pixel value in x-direction            { let x1 }
* Initial pixel value in y-direction            { let y1 }
* End Point pixel value in x-direction     { let x2 }
* End Point pixel value in y-direction     { let y2 }

2. Now all inputs are  given , Now first input the initial pixels point

putpixel ( x1, y1 )

3. Now we will add the an increment value to initial x and y coordinates and this increment value is added upto End Point

4. The Increment value is calculated by

dx = x2 - x1   // In x-Direction
dy = y2 - y1   // In y-Direction

Here dx is the how much total distance to cover in x-direction to reach the End coordinate in x-direction
Here dy is the how much distance to cover in y-direction to reach the End coordinate in y-direction

5. Now find the how must distance to cover at one time or at one loop run

6. This is calculated by dividing the dx and dy by a step

7. value of step will be value among dx or dy

If dx > dy then
{
step = dx
}
else
{
step = dy
}

8. After calculating step change in x-direction let be cx will be

cx =  dx/step
This will give how much distance to cover in each loop run or at one time how much increment will takes place

Similarly in y-direction
cy =  dy/step
This will give how much distance to cover in each loop run or at one time how much increment will takes place

9. Now Start a loop and it will continue upto value in Step variable

increment x and y as :-

x= cx + x
y= cy + y
setpixel ( x , y )  // Put or set the New pixel

10. Now at execution of Loop the line will be printed

For Any query feel free and post the question you will get feedback within 2 hours

## STATIC DATA MEMBER

As we know Each object of a particular specified class consist of its own data . But if we declared Data item is as static data item then this static data item or we can simply say static variable or static member function will be available for global access for all objects of class . It means if you have declared a variable for member function as static then this can be accessed by all objects of class .

I mean to say if you have declared a variable as static then you have assigned it value '5'  through Obj1 object of class . Then if you have created a new object Obj2 and accessing value of static variable that it is still holding value '5' if it is accessed through Obj2 .

A Static Variable is visible or accessible only within the class or only by members of class But its lifetime is throughout the program means it can hold the same value throughout the lifetime of program

## DECLARATION :-

Static int stvar;

## INITIALIZATION :-

*                                     int abc : : stvar =10

In this Stvar is initialized with value '10' and abc is class name .

*              int abc : :  : stvar ;
In this abc is classname and now stvar will be assigned '0' value

SIMPLE PROGRAM TO SHOW USE OF STATIC VARIABLE
``` #include<iostream.h> #include<conio.h> class static_var { static int count;    //static member of class public : void incr_staticvar() { count++; }  void outputc() { cout<<"Value of Static variable Count :- "<<count<<endl; } }; int static_function : : count; void main() { clrscr(); static_var obj1,obj2,obj3,obj4; obj1.incr_staticvar(); obj2.incr_staticvar(); obj3.incr_staticvar(); obj4.incr_staticvar(); cout<<"\nAfter Increment of static variable by Four Different objects is :-\n"; obj1.outputc ( ); obj2.outputc ( ); obj3.outputc ( ); obj4.outputc ( ); ```

```       getch(); }```

OUTPUT :-

## STATIC MEMBER FUNCTION

The Word Static means fixed . To  make a member function static you have to precede the word static to it .

Facts About Static Member Functions :-

*  The main usage of static functions is they are made to access static members of class or static variables of class that are declared in same class in which static member functions are declared

* These can be called outside class or in main function without using Object of class.

### HOW TO CALL STATIC MEMBER FUNCTION

CLASS_NAME  : :  NAME_OF_FUNCTION

SIMPLE PROGRAM TO SHOW USE OF STATIC MEMBER FUNCTIONS
``` #include< iostream.h > #include< conio.h > class static_function { int a; static int count;    //Declaration of static Data member of class  public : static_function( )    // Constructor that is initializing variable a to 0 { a=0; } void non_static( )    // public member function that is incrementing a variable { a++; } void outputn ( )  // public member function to cout value of a { cout<<"A :-  "<<a<<endl; } void incr_staticvar( )   // public member function to increment static variable { count++; } static void outputc( )  // public member function to cout value of static variable { cout<<"Value of Static variable Count :- "<<count<<endl; } }; int static_function :: count; void main( ) { clrscr(); static_function obj1,obj2,obj3,obj4;   //creation of four object of class static_function cout<<"Initially "; static_function : : outputc();     // calling static function obj1.incr_staticvar();    //calling public funtion to increment static variable obj2.incr_staticvar(); obj3.incr_staticvar(); obj4.incr_staticvar(); ```
`cout<<"\nAfter Increment of static variable by Four Different objects is :-\n";`
``` static_function ::outputc(); obj1.non_static();    // function to increment a variable obj2.non_static(); obj3.non_static(); obj4.non_static(); cout<<cout<<"After Increment of Variable 'A' by Four Different objects i :-"; obj1.outputn(); obj2.outputn(); obj3.outputn(); obj4.outputn();       getch(); }```

OUTPUT :-

## write Program To Print All Permutations of given string

Combination programs require good understanding of mathematics . In combination or permutation concepts some formulas are used to identify how this combination of letters will be formed and how many combinations will be made .

Formula for Permutation :-
N! / (N-r)!
Where N is the total number of characters that are available in your input string .
Where r is total number of characters that will be taken at one time .

Like if total number of characters in string is '5 ' and total number of characters taken at one time is '4' Then

Permutation = 5! / (5-4)!  = 120

Formula for Combination :-
N! / r!  * (N-r)!

Where N is the total number of characters that are available in your input string .
Where r is total number of characters that will be taken at one time .

Program
In the following program we are making a program in C++ to print all possible combinations of  "abcd" string . As we can see we have to find permutation . So formula for it is :-

N! / (N-r)!
4! / (4-4)!  =24
So 24 total combinations will be made from string "abcd" . There are four characters and 24 combinations . so each character will remain at one position for 24/4 time means 6 times.

## Program To Print all possible combinations of all characters of  "abcd" string .

`#include< iostream.h >`

#include< conio.h >
main ( )
{
clrscr ( );
int n=4;        // Here n is 4 so this programs prints all possible combinations for
char a;      // 4 character you can specify any value you want
cout<<"This program gives all possible combinations of four characters "<<endl;
cout<<"\nEnter Four Characters :-  ";

//Input four character from user in a [  ] array
for(int x=0;x<=3;x++)
{
cin>>a[x];
}

cout<<"\nNow Combinations "<<" is :- \n"<<endl;

for(int z=0;z<=n-1;z++)
{
for(int j=0;j<=n-2;j++)
{
int temp;
temp=a[n-1];
a[n-1]=a[n-2];
a[n-2]=temp;
cout<<"\t";

for (int l=0;l<=n-1;l++)
{
cout<<a[l];
}

cout<<"\t";

temp=a[n-3];
a[n-3]=a[n-1];
a[n-1]=temp;

for ( int l2=0;l2<=n-1;l2++)
{
cout<<a[l2];
}
}

int temp1;
temp1  =  a;
a  =  a[z+1];
a[z+1]  =  temp1;

cout<<"\n";
}
getch();

}

OUTPUT :-

CODE EXPLANATION

## cout<<"\nEnter Four Characters :-  "; //Input four character from user in a [  ] array for(int x=0;x<=n;x++) {  cin>>a[x]; }

In This Block of code we are getting input of four character whose combinations are generated by this program. In this we have used a for loop that consist of x counter that is initialized from 0 and it will continue upto 3 that allows user to enter 4 character to get their all possible combinations

Code below is logic of this program that given all possible combinations of entered characters
I have explained it with comments with it

`for(int z=0;z<=n-1;z++)    // loop continues from 0 to 3 (  if n is 4 ){for(int j=0;j<=n-2;j++)       // loop continues from 0 to 2 (  if n is 4 ){{int temp;temp=a[n-1];a[n-1]=a[n-2];a[n-2]=temp;cout<<"\t";for (int l=0;l<=n-1;l++){ cout<<a[l]; }cout<<"\t";temp=a[n-3];a[n-3]=a[n-1];a[n-1]=temp;for ( int l2=0;l2<=n-1;l2++) {cout<<a[l2]; } } int temp1; temp1  =  a; a  =  a[z+1]; a[z+1]  =  temp1; cout<<"\n";  }`

This code of block produces the all possible combinations of given input character by placing each character at all positions within the string each character including its original position within string will exchanged with or replaced with every position within the string so as to generate unique string each time

## Algorithm and Implementation Program of Quick Sort

Quick Sort is a Sorting Algorithm based on Divide And Conquer Technique. In this at every step element is placed in its proper position.It performs very well on a longer list. It works recursively, by first selecting a random "Pivot value" from the list. Then it partitions the list into elements that are less than the pivot and greater the pivot and greater than the pivot. The problem  of sorting a given list is reduced to the problem of sorting two sublists It is to be noted that the reduction step in the quick sort finds the final position of particular element; which can be accomplished by scanning that last element of list from the right to left and check with the element.

Quick sort is Developed by C.A.B. Hoare. The main purpose of quick sort is to find the element that partitions the array into tow halves and to place it at its proper location in the array.

## Working Of Quick Sort

Before we start the learning how quick sort works, we make some assumptions . Set the index of first element of array to LOC and LEFT variable and index of last element of the array to RIGHT variable. Then proceeds as follows :-

1. Start with element pointed to by Right. The array is scanned from right to left , comparing each element on the way with the element pointed by LOC till either.

( a ) Element smaller than the element pointed to by LOC is found and elements are interchanged . Procedure continues with Step2.

( b ) If the value of the RIGHT becomes equal to value of LOC, the procedure terminates here. This indicates that element is placed in its final position.

2.  Start with element pointed to by LEFT. The array is scanned from left to right, comparing each element on the way with the element pointed by LOC till either.

( a ) Element greater than the element pointed to by LOC is found . In this case the elements are interchanged and procedure continues with step 1.
( b ) If the value of LEFT becomes equal to value of LOC , athea procedure terminates. This condition indicates that the element is placed in its final position

At the end of this procedure the first element ( PIVOT ) of original array is placed in its final location in the sorted array. The elements to its left will be less than this element and element to the right will be greater than this element . Now whole procedure that we applied on complete file will be applied on first subfile ( first index to LOC-1) and second (LOC + 1 to last index ) until we get the sorted array

## Algorithm : QUICK SORT

Consider an Array( A ) with N elements having LB as lowerbound and UB as upperbound.

ALGORITHM : QUICK_SORT(A, LB, UB )

Step 1      If         ( LB < UB ) then
P = SUB_ARRAY (A, LB, UB )
QUICK_SORT(A, LB, P-1 )
QUICK_SORT(A, P+1, UB )
Else

// Print sorted Array

Step 2    End

The above function is using the Divide and conquer strategy for algorithms. In above step we are dividing a large available Array named 'A' into smaller arrays and then we are passing these smaller arrays to SUB_ARRAY function that sorts the small list . And get back to Quick_Sort function and then again the divide the remaining list into another portion of a small array and then again take it to SUB_ARRAY function to sort this small array list in this way full or all elements of array are sorted

ALGORITHM : SUB_ARRAY(A, LB, UB )

Step 1      Set LEFT = LB,
Set RIGHT = UB,
Set LOC = LB

Step 2     Repeat step 3 and 4

Step 3      // Scanning Array from Right To Left
Repeat while A[LOC] <= A[ Right] and LOC != Right
Right = Right -1
( a ) If LOC == Right then
Return LOC
( b ) Interchange A [LOC] & A [RIGHT]
( c ) Set LOC == RIGHT

Explanation :- In Step 3 Array 'A' is scanned starting from Rightmost element of array and going towards the Left of array . In this step this algorithm finds the element which is greater the element at A[LOC] or pivot element and  when element which is greater than pivot is found it is replaced with A[LOC] and LOC is set the Location of element with which we have replaced the location it means A[RIGHT] and else the Right is decremented by 1 until it comes to location same as LOC

Step 4     // Scanning Array  from LEFT to Right
Repeat while A[LOC] >= A[LEFT] and LOC != LEFT
LEFT = LEFT +1
( a ) If LOC == LEFT then
Return LOC
( b ) Interchange A[LOC] and A[LEFT]
( c ) Set LOC = LEFT

Explanation :- In Step 4 Array 'A' is scanned starting from Leftmost element of array and going towards the Right of array . In this step this algorithm finds the element which is smaller the element at A[LOC] or pivot element and  when element which is smaller than pivot is found it is replaced with A[LOC] and LOC is set the Location of element with which we have replaced the location means A[LEFT].

Step 5      End

## Implementation of Quick Sort Algorithm in Cplusplus ( c++ ) Program

``` #include< iostream.h > #include< conio.h > int a, n, lb, loc, ub, left, right, temp, temp1; void quicksort(int,int,int); int pivot(int[],int,int); void main() { cout<<"Enter size of array"; cin>>n; cout<<"Enter Array Elements "; for(int i=0;i<n;i++) { cin>>a[i]; } quicksort(a,0,n-1); for(int z=0;z<n;z++) { cout<<" "<<a[z]; } getch(); } void quicksort(int a[], int lb, int ub) { int p; if(lb<ub) { p=pivot(a,lb,ub); quicksort(a,lb,p-1); quicksort(a,p+1,ub); } } int pivot( int a[],int lb,int ub ) { for(int z=0;z<n;z++) { cout<<" "<<a[z]; } cout<<endl; left =lb; right = ub; loc  =lb; cout<<"right is :- "<<right; cout<<"\tloc is :-"<<loc; cout<<"left is :- "<<left;  cout<<"Now right \n"; while((a[loc]<=a[right]) && (loc!=right)) { right=right-1; } if(loc==right) { return loc; } temp=a[loc]; a[loc]=a[right]; a[right]=temp; loc=right; cout<<"Now left \n"; while((a[left]<=a[loc]) && (loc!=left)) { left=left+1; } if(loc==left) { return loc; } temp1=a[loc]; a[loc]=a[left]; a[left]=temp1; loc=left; ```
``` ```
`}`

``` ```

 OUTPUT QUICK SORT PROGRAM Output of Quick Sort Program

For any type of more explanation to this program and for any suggest to this post you can freely comment . your comment are very crucial to us.

## C program To Shutdown Computer in Windows xp

This is a program to Shutdown your computer by using C programming language code. This code will first ask you for the confirmation whether youwant to shutdown the computer or not. Depending on confirmation passed by user This program shutdown the computer or exit from executionif user don't want to shutdown computer. Firstly it will asks you
to shutdown your computer if you press 'y' the  your computer will shutdown in 30 seconds,

## Logic Behind This program

In this program we have used library file that invoked or calls function of  "stdlib.h". This function in stdlib.h lubrary is used to  run an exe file "shutdown.exe" which is availiable in directory path
"C:\WINDOWS\system32"

Windows XP provides numerous options to use or parameters to pass to shutdown.exe
while executing shutdown.exe

For Example
-s option shutdown the computer after 30 seconds

-t :- This option allows you to specify the time along with shutdown command to specify after how much time computer will be shutdown If you want to shutdown your computre immediately then you canuse  "shutdown -s -t 0"

Where -s parameter is stands for shutdown it denotes or pass parameter to shutdown.exe file to denotes shutdown.exe that user wants to shutdown this computer

"-t 0"  this denotes we are specifying time so that after that time computer must be shutdown. you can also specify time you want

-r This paramter is used to restart your computer

``` #include <stdio.h> #include <stdlib.h> main() {    char ch;    printf("Do you want to shutdown your computer now )\n");    printf("Press Y for Yes\n");    printf("Press N for No\n");    scanf("%c",&ch);    if (ch == 'y' || ch == 'Y')       system("C:\\WINDOWS\\System32\\shutdown -s");    return 0; }```

## C program To Shutdown Computer in Windows 7

``` #include <stdio.h> #include <stdlib.h> main() {    char ch;    printf("Do you want to shutdown your computer now \n");    printf("Press Y for Yes\n");    printf("Press N for No\n");    scanf("%c",&ch);    if (ch == 'y' || ch == 'Y')       system("C:\\WINDOWS\\System32\\shutdown /s");    return 0; }```

## C program To Shutdown Computer in Ubuntu

To Run this program in Ubuntu you must be logged in as root user
``` #include <stdio.h> int main() {   system("shutdown -P now");   return 0; } ```

## C Program To Shutdown Restart Logoff and Hibernate Program

The below availibale program can be used to shutdown your computer , to restart, logoff and hibernate you computer using c programming language

``` #include<stdio.h> #include<dos.h> #include<stdlib.h> #include<conio.h> void main() { int ch; clrscr(); printf("\n\n------------SHUTDOWN MENU----------------\n"); printf("Press1 For Shutdownn\nPress2 For Restart\n Press3  For Logoff\n Press4  for Hibernate\n5.exit”"); printf("\nEnter Your choice : "); scanf("%d",&ch); switch(ch) { case 1:system("shutdown -s"); break; case 2:system("shutdown -r"); break; case 3:system("shutdown -l"); break; case 4:system("shutdown -h"); break; case 5:exit(1); break; default:printf("Invalid choice"); } getch();``` }