Programmers Lounge

Matrix Operations

2008-06-08T03:00:00.000-07:00


/* Subhranath Chunder - Matrix Operations */

/* A program to implement the following operation on two matrices:
   a. Addition
   b. Multiplication
   c. Transposition
   d. Determinant */

#include<stdio.h>
#include<conio.h>
#include<math.h>

/* Function declarations */
void print(int[][100],int,int);
void add(int[][100],int,int,int[][100],int,int);
void multiply(int[][100],int,int,int[][100],int,int);
void transpose(int[][100],int,int);
int determinant(int[][100],int);

/* Main Program */
void main()
{
   int inp1[100][100],inp2[100][100],m1,n1,m2,n2,i,j,option=0;
   clrscr();

   /* The values of the matrices are accepted */
   printf("Enter the dimensions of the first matrix in the form mXn: ");
   scanf("%dX%d",&m1,&n1);
   printf("Enter the values of the first matrix:\n");
   for(i=0;i<m1;++i)
   {
      for(j=0;j<n1;++j)
         scanf("%d",&inp1[i][j]);
   }
   printf("\n\nEnter the dimensions of the second matrix in the form mXn: ");
   scanf("%dX%d",&m2,&n2);
   printf("Enter the values of the second matrix:\n");
   for(i=0;i<m2;++i)
   {
      for(j=0;j<n2;++j)
         scanf("%d",&inp2[i][j]);
   }

   /* Main Menu - where the user chooses what he wants to do */
   while(option==0)
   {
      clrscr();
      printf("You can perform the following operations on the matrices:\n\n1. Addition\n2. Multiplication\n3. Transposition\n4. Determinant\n5. Exit\n\nEnter Choice: ");
      scanf("%d",&option);
      clrscr();

      /* Performs addition on the two matrices */
      if(option==1)
      {
         add(inp1,m1,n1,inp2,m2,n2);
         getch();
      }

      /* Performs multiplication on the two matrices */
      if(option==2)
      {
         multiply(inp1,m1,n1,inp2,m2,n2);
         getch();
      }

      /* Transposes a specified matrix */
      while(option==3)
      {
         printf("Which matrix would you like to transpose?\n\n1. First Matrix\n2. Second Matrix\n\nEnter Choice: ");
         scanf("%d",&option);
         clrscr();
         if(option==1 || option==2)
         {
            if(option==1)
               transpose(inp1,m1,n1);
            if(option==2)
               transpose(inp2,m2,n2);
            getch();
         }
         else
            option=3;
      }

      /* Finds the determinant of a specified matrix */
      while(option==4)
      {
         printf("Find the determinant of which matrix?\n\n1. First Matrix\n2. Second Matrix\n\nEnter Choice: ");
         scanf("%d",&option);
         clrscr();
         if(option==1 || option==2)
         {
            if(option==1)
            {
               if(m1==n1)
                  printf("The determinant of the matrix is: %d",determinant(inp1,m1));
               else
                  printf("The derterminant of the matrix cannot be determined.");
            }
            if(option==2)
            {
               if(m2==n2)
                  printf("The determinant of the matrix is: %d",determinant(inp2,m2));
               else
                  printf("The derterminant of the matrix cannot be determined.");
            }
            getch();
         }
         else
            option=4;
      }

      /* Exits the program */
      if(option==5)
         break;

      /* Returns the control back to main menu */
      option=0;
   }
}
/* Main Program Ends */

/* Performs addition on the two specified matrices */
void add(int arr1[][100],int m1,int n1,int arr2[][100],int m2,int n2)
{
   int arr3[100][100],i,j;
   if(m1==m2 && n1==n2)
   {
      for(i=0;i<m1;++i)
      {
         for(j=0;j<n1;++j)
            arr3[i][j]=arr1[i][j]+arr2[i][j];
      }
      printf("The sum of the two matrices is given below:\n\n");
      print(arr3,m1,n1);
   }
   else
      printf("The matrices cannot be added");
}

/* Performs multiplication on the two specified matrices */
void multiply(int arr1[][100],int m1,int n1,int arr2[][100],int m2,int n2)
{
   int arr3[100][100],i,j,k;
   if(n1==m2)
   {
      for(i=0;i<m1;++i)
      {
         for(j=0;j<n2;++j)
         {
            arr3[i][j]=0;
            for(k=0;k<n1;++k)
               arr3[i][j]+=arr1[i][k]*arr2[k][j];
         }
      }
      printf("The product of the two matrices is given below:\n\n");
      print(arr3,m1,n2);
   }
   else
      printf("The matrices cannot be multiplied");
}

/* Transposes a specified matrix */
void transpose(int arr[][100],int m,int n)
{
   int arr2[100][100],i,j;
   for(i=0;i<m;++i)
   {
      for(j=0;j<n;++j)
         arr2[j][i]=arr[i][j];
   }
   printf("The transpose of the matrix is given below:\n\n");
   print(arr2,n,m);
}

/* Finds the determinant of a specified matrix */
int determinant(int arr[][100],int n)
{
   int temp[100][100],a,b,result=0,i,j,k;
   if(n==1)
      return(arr[0][0]);
   else
   {
      for(i=0;i<n;++i)
      {
         a=0;
         b=0;
         for(j=1;j<n;++j)
         {
            for(k=0;k<n;++k)
            {
               if(k!=i)
               {
                  temp[a][b]=arr[j][k];
                  ++b;
               }
            }
            b=0;
            ++a;
         }
         result+=arr[0][i]*determinant(temp,n-1)*pow(-1,i);
      }
   }
   return result;
}

/* Prints a matrix of specified dimension */
void print(int arr[][100],int m,int n)
{
   int i,j;
   for(i=0;i<m;++i)
   {
      for(j=0;j<n;++j)
         printf("%d\t",arr[i][j]);
      printf("\n");
   }
}

A program demonstrating various operations on integer array

2008-06-08T02:56:00.000-07:00


/* Subhranath Chunder - A program demonstrating various operations on integer array */

#include<stdio.h>
#include<conio.h>

/* Funtion declarations */
void printarray1(int[],int);
void printarray2(int[],int);
int maximum(int[],int);
int minimum(int[],int);
void ascend(int[],int);
void descend(int[],int);
int search(int,int[],int);
void insertion(int,int,int[],int);
void deletion(int,int[],int);
void merge(int,int[],int,int[]);
void reverse(int,int[]);

/* Main Program */
void main()
{
   int inp[100],n,option=0,i,temp1,temp2;
   clrscr();

   /* User inputs the elements of the array */
   printf("Enter the no. of elements you would like to enter: ");
   scanf("%d",&n);
   printf("\nEnter the numbers: ");
   for(i=0;i<n;++i)
      scanf("%d",&inp[i]);

   /* Main Menu - where the user chooses what he wants to do */
   while(option==0)
   {
      clrscr();
      printf("You can perform the following options on the array.\n\n1. Find the maximum and minimum elements.\n2. Sort.\n3. Search.\n4. Insertion.\n5. Deletion.\n6. Merging.\n7. Reversing.\n8. Exit\n\nEnter your option: ");
      scanf("%d",&option);

      /* Shows the maximum and minimum element of the array */
      if(option==1)
      {
         clrscr();
         printf("The maximum element of the array is: %d",maximum(inp,n));
         printf("\n\nThe minimum element of the array is: %d",minimum(inp,n));
         getch();
         option=0;
      }

      /* Sort the array either in ascending or descending order */
      while(option==2)
      {
         clrscr();
         printf("Sort the array:\n\n1. In Ascending Order.\n2. In Descending Order.\n\nEnter Choice: ");
         scanf("%d",&option);
         if(option==1 || option==2)
         {
            if(option==1)
               ascend(inp,n);
            if(option==2)
               descend(inp,n);
            printarray2(inp,n);
            getch();
            option=0;
         }
         else
            option=2;
      }

      /* Provides the option to search for the position of an element in the array */
      if(option==3)
      {
         clrscr();
         printf("Enter the value of the element you want to search: ");
         scanf("%d",&temp1);
         temp2=search(temp1,inp,n);
         if(temp2==-1)
            printf("\n\nValue not found.");
         else
            printf("\n\n%d was found at the following position: %d",temp1,temp2);
         getch();
         option=0;
      }

      /* Inserts an element at any user defined position of the array */
      if(option==4)
      {
         clrscr();
         printarray1(inp,n);
         printf("\n\nEnter the position of the array where you want to insert a new element: ");
         scanf("%d",&temp1);
         printf("\nEnter the element: ");
         scanf("%d",&temp2);
         insertion(temp2,temp1,inp,n);
         ++n;
         printarray2(inp,n);
         getch();
         option=0;
      }

      /* Removes an element from any given position of the array */
      if(option==5)
      {
         clrscr();
         printarray1(inp,n);
         printf("\n\nEnter the position of the element that you want to delete: ");
         scanf("%d",&temp1);
         deletion(temp1,inp,n);
         --n;
         printarray2(inp,n);
         getch();
         option=0;
      }

      /* Merges a set of elements with the existing array */
      if(option==6)
      {
         int inp2[100];
         clrscr();
         printarray1(inp,n);
         printf("\n\nEnter the no elements you would like to merge with the existing array: ");
         scanf("%d",&temp1);
         printf("Enter the elements: ");
         for(i=0;i<temp1;++i)
            scanf("%d",&inp2[i]);
         merge(n,inp,temp1,inp2);
         n=n+temp1;
         printarray2(inp,n);
         getch();
         option=0;
      }

      /* Reverses an element of the array */
      if(option==7)
      {
         clrscr();
         printarray1(inp,n);
         printf("\n\nEnter the position of the element that you want to reverse: ");
         scanf("%d",&temp1);
         reverse(temp1,inp);
         printarray2(inp,n);
         getch();
         option=0;
      }

      /* Exits the program */
      if(option==8)
         break;

      /* Returns the control back to main menu if an invalid option is selected from the main menu */
      else
         option=0;
   }
}
/* Main Program Ends */

/* Prints the structure of the array */
void printarray1(int a[],int n)
{
   int i;
   printf("\nThe structure of the array is given below:\n\n------------------\n%8s%10s\n------------------","Position","Element");
   for(i=0;i<n;++i)
      printf("\n%8d%10d",i,a[i]);
   printf("\n------------------\n");
}

/* Prints the structure of the array after any modification */
void printarray2(int a[],int n)
{
   int i;
   printf("\nThe structure of the modified array is given below:\n\n------------------\n%8s%10s\n------------------","Position","Element");
   for(i=0;i<n;++i)
      printf("\n%8d%10d",i,a[i]);
   printf("\n------------------\n\n<Press any key to continue>\n");
}

/* Returns the value of the maximum element of an array */
int maximum(int a[],int n)
{
   int max,i;
   max=a[0];
   for(i=1;i<n;++i)
   {
      if(a[i]>max)
         max=a[i];
   }
   return(max);
}

/* Returns the value of the minimum element of an array */
int minimum(int a[],int n)
{
   int min,i;
   min=a[0];
   for(i=1;i<n;++i)
   {
      if(a[i]<min)
         min=a[i];
   }
   return(min);
}

/* Sorts an array in ascending order */
void ascend(int a[],int n)
{
   int i,j,temp;
   for(i=0;i<n-1;++i)
   {
      for(j=0;j<n-1-i;++j)
      {
         if(a[j]>a[j+1])
         {
            temp=a[j];
            a[j]=a[j+1];
            a[j+1]=temp;
         }
      }
   }
}

/* Sorts an array in descending order */
void descend(int a[],int n)
{
   int i,j,temp;
   for(i=0;i<n-1;++i)
   {
      for(j=0;j<n-1-i;++j)
      {
         if(a[j]<a[j+1])
         {
            temp=a[j];
            a[j]=a[j+1];
            a[j+1]=temp;
         }
      }
   }
}

/* Searches for the position of any particular value from an array */
int search(int key,int a[],int n)
{
   int i;
   for(i=0;i<n;++i)
   {
      if(a[i]==key)
         return(i);
   }
   return(-1);
}

/* Inserts an element at any given position of an existing array */
void insertion(int element,int pos,int a[],int n)
{
   int i;
   for(i=n;i>pos;--i)
      a[i]=a[i-1];
   a[pos]=element;
}

/* Deletes an element from any given position of an existing array */
void deletion(int pos,int a[],int n)
{
   int i;
   for(i=pos;i<n-1;++i)
      a[i]=a[i+1];
}

/* Merges a set of elements with an existing array */
void merge(int n,int a[],int m,int b[])
{
   int i,j;
   for(i=n,j=0;i<m+n;++i,++j)
      a[i]=b[j];
}

/* Reverse the value of an element at any given position of an array */
void reverse(int pos,int a[])
{
   int i,sum=0;
   while(a[pos]>0)
   {
      sum=sum*10+a[pos]%10;
      a[pos]/=10;
   }
   a[pos]=sum;
}

Binary Search Using Recursion

2008-06-08T02:54:00.000-07:00


/* Subhranath Chunder - Binary Search using Recursion */

#include<stdio.h>
#include<conio.h>

void sort(int a[],int n);
int search(int t,int a[],int lb,int ub);
void main()
{
   int n,inp[200],i,key,result;
   clrscr();
   printf("Enter the no. of terms: ");
   scanf("%d",&n);
   printf("Enter the values: ");
   for(i=0;i<n;++i)
      scanf("%d",&inp[i]);
   printf("Enter the value to search: ");
   scanf("%d",&key);
   sort(inp,n);
   printf("The sorted array is given below:\n");
   for(i=0;i<n;++i)
      printf("%d ",inp[i]);
   result=search(key,inp,0,n-1);
   if(result==-1)
      printf("\nValue Not Found");
   else
      printf("\nThe value was found at position %d of the sorted array.",result);
   getch();
}

void sort(int a[],int n)
{
   int i,j,temp;
   for(i=0;i<n-1;++i)
   {
      for(j=0;j<n-1-i;++j)
      {
         if(a[j]>a[j+1])
         {
            temp=a[j];
            a[j]=a[j+1];
            a[j+1]=temp;
         }
      }
   }
}

int search(int key,int a[],int lb,int ub)
{
   int middle;
   if(lb<=ub)
   {
      middle=(lb+ub)/2;
      if(a[middle]==key)
         return(middle);
      if(key<a[middle])
         return search(key,a,lb,middle-1);
      else
         return search(key,a,middle+1,ub);
   }
   return(-1);
}

Binary Search

2008-06-08T02:46:00.000-07:00


/* Subhranath Chunder - Binary Search */

#include<stdio.h>
#include<conio.h>

void sort(int a[],int n);
int search(int t,int a[],int n);
void main()
{
   int n,inp[200],i,key,result;
   clrscr();
   printf("Enter the no. of terms: ");
   scanf("%d",&amp;n);
   printf("Enter the values: ");
   for(i=0;i<n;++i)
      scanf("%d",&amp;inp[i]);
   printf("Enter the value to search: ");
   scanf("%d",&amp;key);
   sort(inp,n);
   printf("The sorted array is given below:\n");
   for(i=0;i<n;++i)
      printf("%d ",inp[i]);
   result=search(key,inp,n);
   if(result==-1)
      printf("\nValue Not Found");
   else
      printf("\nThe value was found at position %d of the sorted array.",result);
   getch();
}

void sort(int a[],int n)
{
   int i,j,temp;
   for(i=0;i<n-1;++i)
   {
      for(j=0;j<n-1-i;++j)
      {
         if(a[j]>a[j+1])
         {
            temp=a[j];
            a[j]=a[j+1];
            a[j+1]=temp;
         }
      }
   }
}

int search(int key,int a[],int n)
{
   int lb,ub,middle;
   lb=0;
   ub=n-1;
   while(lb<=ub)
   {
      middle=(lb+ub)/2;
      if(a[middle]==key)
         return(middle);
      if(key<a[middle])
         ub=middle-1;
      else
         lb=middle+1;
   }
   return(-1);
}

CONIO.H Documentation (Borland Turbo C++)

2008-04-02T02:34:00.000-07:00

CONIO.H Documentation

Functions:

cgets	2	clreol	2
clrscr	3	cprintf	3
cputs	4	cscanf	5
delline	5	getch	6
getche	6	getpass	7
gettext	7	gettextinfo	9
gotoxy	9	highvideo	10
insline	10	inp	11
inport	12	inportb	12
inpw	11	kbhit	14
lowvideo	10	movetext	14
normvideo	10	outp	11
outport	12	outportb	12
outpw	11	putch	15
puttext	7	_setcursortype	16
textattr	16	textbackground	16
textcolor	16	textmode	18
ungetch	19	wherex	19
wherey	19	window	20



Constants, data types, and global variables:

BLINK	20	COLORS	20
directvideo	21	_NOCURSOR	16
_NORMALCURSOR	16	_SOLIDCURSOR	16
text_info	22	text_modes	22
_wscroll	22

         
 

   


cgets

Reads string from console

Declaration:  char *cgets(char *str);

Remarks:

cgets reads a string of characters from the console and stores the string (and the string length) in the location *str.
Before you call cgets, set str[0] to the maximum length of the string to be read.
cgets reads characters until it encounters a carriage-return/linefeed combination (CR/LF), or until the maximum allowable number of characters have been read.
If cgets reads a CR/LF, it replaces the CR/LF with a \0 (null terminator) before storing the string.
On return, str[1] is set to the number of characters actually read.
The characters read start at str[2] and end with a null terminator, so str must be at least (str[0] + 2) bytes long.

Return Value:

  On success, returns a pointer to str[2].

Example:

 #include 
#include 

int main(void)
{
  char buffer[83];
  char *p;

  /* There's space for 80 characters plus the NULL terminator */
  buffer[0] = 81;

  printf("Input some chars:");
  p = cgets(buffer);
  printf("\ncgets read %d characters: \"%s\"\n", buffer[1], p);
  printf("The returned pointer is %p, buffer[0] is at %p\n", p, &buffer);

  /* Leave room for 5 characters plus the NULL terminator */
  buffer[0] = 6;

  printf("Input some chars:");
  p = cgets(buffer);
  printf("\ncgets read %d characters: \"%s\"\n", buffer[1], p);
  printf("The returned pointer is %p, buffer[0] is at %p\n", p, &buffer);
  return 0;
}


clreol

Clears to end of line in text window

Declaration:  void clreol(void);

Remarks:

clreol clears all characters from the cursor position to the end of the line within thecurrent text window, without moving the cursor.

Return Value:  None

Example:

 #include 

int main(void)

{
  clrscr();
  cprintf("The function CLREOL clears all characters from the\r\n");
  cprintf("cursor position to the end of the line within the\r\n");
  cprintf("current text window, without moving the cursor.\r\n");
  cprintf("Press any key to continue . . .");
  gotoxy(14, 4);
  getch();

  clreol();
  getch();

  return 0;
}


clrscr

Clears text mode window

Declaration:  void clrscr(void);

Remarks:

clrscr clears the current text window and places the cursor in the upper left-hand corner (at position 1,1).

Return Value:  None

Example:

#include 

int main(void)
{
  int i;

  clrscr();
  for (i = 0; i <>
     cprintf("%d\r\n", i);
  cprintf("\r\nPress any key to clear screen");
  getch();

  clrscr();
  cprintf("The screen has been cleared!");
  getch();

  return 0;
}


cprintf

sends formatted output to the text window on the screen

Declaration:  int cprintf (const char *format [, argument, ...]);

Remarks:
format -> Format string

argument -> One of a series of arguments to which the functions apply a format specifier contained in *format

The string is written either directly to screen memory or by way of a BIOS call, depending on the value of directvideo.

cprintf does not translate linefeed characters (\n) into carriage-return/linefeed character pairs (\r\n).

Return Value:

  On success, returns the number of characters output
On error, these functions return EOF

Example:


#include 

int main(void)
{
  /* clear the screen */
  clrscr();

  /* create a text window */
  window(10, 10, 80, 25);

  /* output some text in the window */
  cprintf("Hello world\r\n");

  /* wait for a key */
  getch();
  return 0;
}


cputs

Writes a string to the text window on the screen

Declaration:  int cputs(const char *str);

Remarks:

cputs writes the null-terminated string str to the current text window. It does not append a newline character.
The string is written either directly to screen memory or by way of a BIOS call, depending on the value of directvideo.
cputs does not translate linefeed characters (\n) into carriage-return/linefeed character pairs (\r\n).

Return Value:

  Returns the last character printed.

Example:

 #include 

int main(void)
{
  /* clear the screen */
  clrscr();

  /* create a text window */
  window(10, 10, 80, 25);

  /* output some text in the window */
  cputs("This is within the window\r\n");

  /* wait for a key */
  getch();
  return 0;
}


cscanf

Scans and formats input from the console

Declaration:  int cscanf (char *format [, address, ...]);

Remarks:
address ->  Store the formatted input at an address passed as an argument following *format
format -> Format string

Echoes the input directly to the screen

Return Value:
On success,  return the number of input fields successfully scanned, converted, and stored.
The return value does not include scanned fields that were not stored.
Return value = 0 if no fields were stored.
Return value = EOF if cscanf attempts to read at end-of-file.

Example:

#include 

int main(void)
{
  char string[80];

  /* clear the screen */
  clrscr();

  /* Prompt the user for input */
  cprintf("Enter a string with no spaces:");

  /* read the input */
  cscanf("%s", string);

  /* display what was read */
  cprintf("\r\nThe string entered is: %s", string);
  return 0;
}


delline

(Text mode): Deletes line in text window

Declaration:  void delline(void);

Remarks:

delline deletes the line containing the cursor and moves all lines below it one line up.
delline operates within the currently active text window.

Return Value:  None

Example:

#include 

int main(void)
{
  clrscr();
  cprintf("The function DELLINE deletes the line containing the\r\n");
  cprintf("cursor and moves all lines below it one line up.\r\n");
  cprintf("DELLINE operates within the currently active text\r\n");
  cprintf("window.  Press any key to continue . . .");
  gotoxy(1,2);  /* Move the cursor to the second line and first column */
  getch();

  delline();
  getch();

  return 0;
}


getch and getche

getch gets a character from console but does not echo to the screen

getche gets a character from console, and echoes to the screen

Declaration:

  int getch(void);
int getche(void);

Remarks:

getch reads a single character directly from the keyboard, without echoing to the screen.

getche reads a single character from the keyboard and echoes it to the current text
window, using direct video or BIOS.

Return Value:
Both functions return the character read from the keyboard.

Examples:

getch example

 #include 
#include 

int main(void)
{
 int c;
 int extended = 0;
 c = getch();
 if (!c)
   extended = getch();
 if (extended)
   printf("The character is extended\n");
 else
   printf("The character isn't extended\n");

 return 0;
}

getche example

#include 
#include 

int main(void)
{
  char ch;

  printf("Input a character:");
  ch = getche();
  printf("\nYou input a '%c'\n", ch);
  return 0;
}


getpass

Reads a password

Declaration:  char *getpass(const char *prompt);

Remarks:

getpass reads a password from the system console, after prompting with the null-terminated string prompt and disabling the echo.
It returns a pointer to a null-terminated string of up to eight characters (not counting the null terminator).

Return Value:
Returns a pointer to a static string that is overwritten with each call.

Example:

 #include 

int main(void)
{
  char *password;

  password = getpass("Input a password:");
  cprintf("The password is: %s\r\n", password);
  return 0;
}


gettext, puttext

gettext copies text from text-mode screen to memory

puttext copies text from memory to text-mode screen

Declaration:

  int gettext(int left, int top, int right, int bottom, void*destin);
int puttext(int left, int top, int right, int bottom, void*source);

Remarks:

gettext stores the contents of an onscreen text rectangle defined by (left, top) and (right, bottom) into the area of memory *destin.
gettext reads the rectangle's contents into memory (and puttext puts the stored contents into the rectangle) SEQUENTIALLY from left to right and top to bottom.

puttext writes the contents of the memory area *source out to the onscreen rectangle defined by (left, top) and (right, bottom).
puttext is a text-mode function performing direct video output.

All coordinates are absolute screen coordinates, not window-relative. The upper left corner is (1,1).
Each position onscreen takes 2 bytes of memory.
The first byte is the character in the cell.
The second byte is the cell's video attribute.
The space required for a rectangle w columns wide by h rows high is, bytes = (h rows) x (w columns) x 2

Return Value:

  On success,
   gettext returns 1
   puttext returns a non-zero value
On error, both functions return 0 (for example, if you gave coordinates outside the range of the current screen
     mode)

Examples:

 gettext example

#include 

char buffer[4096];

int main(void)
{
  int i;

  clrscr();
  for (i = 0; i <= 20; i++)
     cprintf("Line #%d\r\n", i);
  gettext(1, 1, 80, 25, buffer);

  gotoxy(1, 25);
  cprintf("Press any key to clear screen...");
  getch();
  clrscr();
  gotoxy(1, 25);
  cprintf("Press any key to restore screen...");
  getch();
  puttext(1, 1, 80, 25, buffer);
  gotoxy(1, 25);
  cprintf("Press any key to quit...");
  getch();

  return 0;
}

puttext example

#include 

int main(void)
{
  char buffer[512];

  /* put some text to the console */
  clrscr();
  gotoxy(20, 12);
  cprintf("This is a test.  Press any key to continue ...");
  getch();

  /* grab screen contents */
  gettext(20, 12, 36, 21,buffer);
  clrscr();

  /* put selected characters back to the screen */
  gotoxy(20, 12);
  puttext(20, 12, 36, 21, buffer);
  getch();

  return 0;
}


gettextinfo

Gets text-mode video information

Declaration: void gettextinfo(struct text_info *r);

Remarks:
gettextinfo fills in a structure with the current text video information.

Return Value:

  gettextinfo does not return. The results are returned in the structure *r.

Example:

 #include 

int main(void)
{
  struct text_info ti;
  gettextinfo(&ti);
  cprintf("window left      %2d\r\n",ti.winleft);
  cprintf("window top       %2d\r\n",ti.wintop);
  cprintf("window right     %2d\r\n",ti.winright);
  cprintf("window bottom    %2d\r\n",ti.winbottom);
  cprintf("attribute        %2d\r\n",ti.attribute);
  cprintf("normal attribute %2d\r\n",ti.normattr);
  cprintf("current mode     %2d\r\n",ti.currmode);
  cprintf("screen height    %2d\r\n",ti.screenheight);
  cprintf("screen width     %2d\r\n",ti.screenwidth);
  cprintf("current x        %2d\r\n",ti.curx);
  cprintf("current y        %2d\r\n",ti.cury);
  return 0;
}


gotoxy

Positions cursor in text window

Declaration:  void gotoxy(int x, int y);

Remarks:

gotoxy moves the cursor to the given position in the current text window.
If the coordinates are invalid, the call to gotoxy is ignored.
Example of invalid coordinates:
 gotoxy(40,30)  /* (35,25) = window's bottom right position */

Return Value:  None

Example:

 #include 

int main(void)
{
  clrscr();
  gotoxy(35, 12);
  cprintf("Hello world");
  getch();
  return 0;
}


highvideo, lowvideo, normvideo

highvideo selects high-intensity text characters

lowvideo selects low-intensity text characters
normvideo selects normal-intensity text characters

Declaration:

  void highvideo(void);
void lowvideo(void);
void normvideo(void);

Remarks:
highvideo selects high-intensity characters by setting the high-intensity bit of the currently selected foreground color.
lowvideo selects low-intensity characters by clearing the high-intensity bit of the currently selected foreground color.
normvideo selects normal characters by returning the text attribute (foreground and background) to the value it had when the program started.

These functions do not affect any characters currently on the screen.
They only affect characters displayed by functions that perform text-mode, direct console output AFTER these video functions are called (such as cprintf).

Return Value:  None

Example:

#include 

int main(void)
{
  normvideo();
  cprintf("NORMAL Intensity Text\r\n");
  return 0;
}


insline

(Text mode): Inserts blank line in text window at cursor position

Declaration: void insline(void);

Remarks:
insline inserts an empty line in the text window at the cursor position using the current text background color.
All lines below the empty one move down one line, and the bottom line scrolls off the bottom of the window.

Return Value:  None

Example:

 #include 

int main(void)
{
  clrscr();
  cprintf("INSLINE inserts an empty line in the text window\r\n");
  cprintf("at the cursor position using the current text\r\n");
  cprintf("background color.  All lines below the empty one\r\n");
  cprintf("move down one line and the bottom line scrolls\r\n");
  cprintf("off the bottom of the window.\r\n");
  cprintf("\r\nPress any key to continue:");
  gotoxy(1, 3);
  getch();
  insline();
  getch();
  return 0;
}


inp, inpw, outp, outpw

inp reads a byte from a hardware port

inpw reads a word from a hardware port
outp outputs a byte to a hardware port
outpw outputs a word to a hardware port

Declaration:
int inp(unsigned portid);
unsigned inpw(unsigned portid);
int outp(unsigned portid, int value);
unsigned outpw(unsigned portid, unsigned value);

Remarks:
Both inp and inpw are macros that read from the input port specified by portid.
Both outp and outpw are macros that write to the output port specified by portid.
inp reads a byte
inpw reads a 16-bit word (the low byte of the word from portid, the high byte from portid + 1)
outp writes the low byte of value
outpw writes the low byte of value to portid, and the high byte to portid + 1, using a single 16-bit OUT instruction

If you call any of these macros when CONIO.H has been included, they are treated as macros that expand to inline code.
If you don't include CONIO.H, or if you do include CONIO.H and #undef the macro, you get the function of the same name.

Return Value:
inp and inpw return the value read
outp and outpw return the parameter "value"

Examples:

inp example

#include 
#include 

int main(void)
{
  int result;
  int port = 0;  /* serial port 0 */

  result = inport(port);
  printf("Word read from port %d = 0x%X\n", port, result);
  return 0;
}

inpw example

#include 
#include 

int main(void)
{
 unsigned result;
 unsigned port = 0;
 result = inpw(port);
 printf("Word read from port %d = 0x%X\n", port, result);
 return 0;
}

outp example

#include 
#include 

int main(void)
{
 unsigned port = 0;
 int value;
 value = outp(port, 'C');
 printf("Value %c sent to port number %d\n", value, port);
 return 0;
}

outpw example

#include 
#include 

int main(void)
{
 unsigned value;
 unsigned port = 0;
 value = outpw(port, 64);
 printf("Value %d sent to port number %d\n", value, port);
 return 0;
}


inport, inportb, outport, outportb

inport reads a word from a hardware port

inportb reads a byte from a hardware port
outport outputs a word to a hardware port
outportb outputs a byte to a hardware port

Declaration:
int inport(int portid);
unsigned char inportb(int portid);
void outport(int portid, int value);
void outportb(int portid, unsigned char value);

Remarks:
inport works just like the 80x86 instruction IN. It reads the low byte of a word from portid, the high byte from portid + 2.
inportb is a macro that reads a byte
outport works just like the 80x86 instruction OUT. It writes the low byte of value to portid, the high byte to portid + 1.
outportb is a macro that writes value

portid -> Inport port that inport and inportb read from;
     outport port that outport and outportb write to
value -> Word that outport writes to portid;
    byte that outportb writes to portid.

If you call inportb or outportb when DOS.H has been included, they are treated as macros that expand to inline code.
If you don't include DOS.H, or if you do include DOS.H and #undef the macro(s), you get the function(s) of the same name.

Return Value:
inport and inportb return the value read
outport and outportb do not return

Examples:

inport example

#include 
#include 

int main(void)
{
 int result;
 int port = 0;
 result = inport(port);
 printf("Word read from port %d = 0x%X\n", port, result);
 return 0;
}

inportb example

#include 
#include 

int main(void)
{
  unsigned char result;
  int port = 0;           /* serial port 1 */

  result = inportb(port);
  printf("Byte read from port %d = 0x%X\n", port, result);
  return 0;
}

outport example

#include 
#include 

int main(void)
{
  int port = 0;
  int value = 'C';

  outport(port, value);
  printf("Value %d sent to port number %d\n", value, port);
  return 0;
}

outportb example

#include 
#include 

int main(void)
{
  int port = 0;
  char value = 'C';

  outportb(port, value);
  printf("Value %c sent to port number %d\n", value, port);
  return 0;
}


kbhit

Checks for currently available keystrokes

Declaration:  int kbhit(void);

Remarks:
kbhit checks to see if a keystroke is currently available.
Any available keystrokes can be retrieved with getch or getche.

Return Value:
On success (if a keystroke is available), returns a non-zero integer
If a keystroke is not available, returns 0.

Example:

 #include 

int main(void)
{
  cprintf("Press any key to continue:");
  while (!kbhit()) /* do nothing */ ;
  cprintf("\r\nA key was pressed...\r\n");
  return 0;
}


movetext

Copies text on screen from one rectangle to another

Declaration:
int movetext(int left, int top, int right,
int bottom, int destleft, int desttop);

Remarks:
movetext copies the contents of the onscreen rectangle defined by left, top, right, and bottom to a new rectangle of the same dimensions.
The new rectangle's upper left corner is position (destleft, desttop).
All coordinates are absolute screen coordinates. Rectangles that overlap are moved correctly.
movetext is a text mode function performing direct video output.

Return Value:
movetext returns non-zero if the operation succeeded.
If the operation failed (for example, if you gave coordinates outside the range of the current screen mode),
movetext returns 0.

Example:

#include

 #include 

int main(void)
{
  char *str = "This is a test string";

  clrscr();
  cputs(str);
  getch();

  movetext(1, 1, strlen(str), 2, 10, 10);
  getch();

  return 0;
}


putch

Outputs character to the text window on the screen

Declaration:  int putch(int ch);

Remarks:
putch outputs the character c to the current text window. It is a text-mode function that performs direct video output to the console.
putch does not translate linefeed characters (\n) into carriage-return/linefeed pairs.
The string is written either directly to screen memory or by way of a BIOS call, depending on the value of directvideo.

Return Value:
On success, putch returns the character printed, c.
On error, it returns EOF.

Example:

 #include 
#include 

int main(void)
{
  char ch = 0;

  printf("Input a string:");
  while ((ch != '\r'))
  {
     ch = getch();
     putch(ch);
  }
  return 0;
}


_setcursortype

Selects cursor appearance

Declaration:  void _setcursortype(int cur_t);

Remarks:
Sets the cursor type to one of the following:
_NOCURSOR     (turns off the cursor)
_SOLIDCURSOR  (solid block cursor)
_NORMALCURSOR (normal underscore cursor)

Return Value:  None

Example:

 #include 

int main(void)
{
  /* Display the normal cursor */
  cprintf("\n\rNormal Cursor: "); getch();

  /* Turn off the cursor */
  _setcursortype(_NOCURSOR);
  cprintf("\n\rNo Cursor    : "); getch();

  /* Switch to a solid cursor */
  _setcursortype(_SOLIDCURSOR);
  cprintf("\n\rSolid Cursor : "); getch();

  /* Switch back to the normal cursor */
  _setcursortype(_NORMALCURSOR);
  cprintf("\n\rNormal Cursor: "); getch();

  return 0;
}


textattr, textbackground, textcolor

textattr sets text attributes for text-window functions

textbackground selects a new text background color
textcolor selects a new character color in text mode

Declaration:

  void textattr(int newattr);
void textbackground(int newcolor);
void textcolor(int newcolor);

Remarks:
These functions work for functions that produce text-mode output directly to the screen (console output functions).
textattr sets both the foreground and background colors in a single call.
textbackground selects the background color.
textcolor selects the foreground character color.

These functions do not affect any characters currently on the screen. Once you have called one of these three functions, all subsequent functions using direct video output (such as cprintf) will use the new attributes or colors.
If you use symbolic color constants, the following limitations apply to the background colors you select:
You can only select one of the first eight colors (0--7).
With textattr, you must shift the selected background color left by 4 bits to move it into the correct "bbb" bit
positions.
NOTE: If you use the symbolic color constants, you must include CONIO.H.

newattr 
This is how color information is encoded in the newattr argument of textattr:
 7   6   5   4 º 3   2   1   0
----------------×----------------
³ B ³ b ³ b ³ b º f ³ f ³ f ³ f ³
----------------×----------------
In this 8-bit newattr parameter,
ffff  = 4-bit foreground color (0 to 15)
bbb = 3-bit background color (0 to 7)
B     = blink-enable bit

Blinking characters 
If the blink-enable bit is on, the character blinks. To turn the bit on in a call to textattr, you add the constant BLINK to the attribute.
To make the characters blink in a call to textcolor, you add 128 to the foreground color. The predefined constant BLINK exists for this purpose; for example,  textcolor(CYAN + BLINK);

Light colors
Some monitors do not recognize the intensity signal used to create the eight "light" colors (8-15). On such monitors, the light colors are displayed as their "dark" equivalents (0-7).

Also, systems that do not display in color can treat these numbers as shades of one color, special patterns, or special attributes (such as underlined, bold, italics, etc.).
Exactly what you'll see on such systems depends on your hardware.

Return Value:  None

Examples:

textattr example

#include 

int main(void)
{
  int i;

  clrscr();
  for (i=0; i<9;>
  {
      textattr(i + ((i+1) <<>
      cprintf("This is a test\r\n");
  }

  return 0;
}

textbackground and textcolor example

#include 

int main(void)
{
  int i, j;

  clrscr();
  for (i=0; i<9;>
  {
      for (j=0; j<80;>
    cprintf("C");
      cprintf("\r\n");
      textcolor(i+1);
      textbackground(i);
  }

  return 0;
}


textmode

Changes screen mode (in text mode)

Declaration:  void textmode(int newmode);

Remarks:
textmode selects a specific text mode.
You can give the text mode (the argument newmode) by using a symbolic constant from the enumeration type text_modes (defined in CONIO.H).
If you use these constants, you must include CONIO.H.
When textmode is called, the current window is reset to the entire screen, and the current text attributes are reset to normal, corresponding to a call to normvideo.
Specifying LASTMODE to textmode causes the most recently selected text mode to be reselected.
textmode should be used only when the screen is in text mode (presumably to change to a different text mode).
When the screen is in graphics mode, use restorecrtmode to escape temporarily to text mode.

Return Value:  None

Example:

 #include 

int main(void)
{
  textmode(BW40);
  cprintf("ABC");
  getch();

  textmode(C40);
  cprintf("ABC");
  getch();

  textmode(BW80);
  cprintf("ABC");
  getch();

  textmode(C80);
  cprintf("ABC");
  getch();

  textmode(MONO);
  cprintf("ABC");
  getch();

  return 0;
}


ungetch

Pushes a character back to the keyboard

Declaration:  int ungetch(int ch);

Remarks:
ungetch pushes the character ch back to the console, causing ch to be the next character read.
ungetch fails if it is called more than once before the next read.

Return Value:
On success, returns the character ch.
On error, returns EOF.

Example:

 #include 
#include 
#include 

int main( void )
{
  int i=0;
  char ch;

  puts("Input an integer followed by a char:");

  /* read chars until non digit or EOF */
  while((ch = getche()) != EOF && isdigit(ch))
     i = 10 * i + ch - 48; /* convert ASCII into int value */

  /* if non digit char was read, push it back into input buffer */
  if (ch != EOF)
     ungetch(ch);

  printf("\n\ni = %d, next char in buffer = %c\n", i, getch());
  return 0;
}


wherex, wherey

wherex gives current horizontal cursor position

wherey gives current vertical cursor position

Declaration:

  int wherex(void);
int wherey(void);

Remarks:
wherex returns the x-coordinate of the current cursor position (within the current text window).
wherey returns the y-coordinate of the current cursor position (within the current text window).

Return Value:
wherex returns an integer in the range 1 to 80.
wherey returns an integer in the range 1 to 25, 1 to 43, or 1 to 50.

Example:

 #include 

int main(void)
{
  clrscr();
  gotoxy(10,10);
  cprintf("Current location is X: %d  Y: %d\r\n", wherex(), wherey());
  getch();

  return 0;
}


window

Defines active text-mode window

Declaration:  void window(int left, int top, int right, int bottom);

Remarks:
The top left corner of the screen is (1,1).
window defines a text window onscreen. If the coordinates are in any way invalid, the call to window is ignored.
(left, top) is the (x, y) position of the window's upper left corner.
(right, bottom) is the (x, y) position of the window's lower right corner.
The minimum size of the text window is one column by one line.
The default window is full screen, with these coordinates:
80-column mode:  (1, 1, 80, 25)
40-column mode:  (1, 1, 40, 25)

Return Value:  None

Example:

 #include 

int main(void)
{

  window(10,10,40,11);
  textcolor(BLACK);
  textbackground(WHITE);
  cprintf("This is a test\r\n");

  return 0;
}

COLORS, CGA_COLORS, and EGA_COLORS

(Enumerated Constants for Colors)
These tables show
  the symbolic constants used to set text attributes on CGA and EGA
  monitors. (Defined in CONIO.H.)
  the drawing colors available for BGI functions running on CGA and EGA
  monitors. (Defined in GRAPHICS.H.)
The COLORS constants are used by these text mode functions:
 textattr     textbackground     textcolor
The CGA_COLORS and EGA_COLORS constants are used by these BGI graphics functions:
setallpalette     setbkcolor     setcolor     setpalette

Valid colors depend on the current graphics driver and current graphics mode.

COLORS (text mode)
|-------------------|Back-³Fore-|
|Constant     ³Value|grnd?³grnd?|
|-------------------|-----³----Ø|
BLACK        ³  0  ³ Yes ³ Yes
BLUE         ³  1  ³ Yes ³ Yes
GREEN        ³  2  ³ Yes ³ Yes
CYAN         ³  3  ³ Yes ³ Yes
RED          ³  4  ³ Yes ³ Yes
MAGENTA      ³  5  ³ Yes ³ Yes
BROWN        ³  6  ³ Yes ³ Yes
LIGHTGRAY    ³  7  ³ Yes ³ Yes
DARKGRAY     ³  8  ³ No  ³ Yes
LIGHTBLUE    ³  9  ³ No  ³ Yes
LIGHTGREEN   ³ 10  ³ No  ³ Yes
LIGHTCYAN    ³ 11  ³ No  ³ Yes
LIGHTRED     ³ 12  ³ No  ³ Yes
LIGHTMAGENTA ³ 13  ³ No  ³ Yes
YELLOW       ³ 14  ³ No  ³ Yes
WHITE        ³ 15  ³ No  ³ Yes
ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÅÄÄÄÄÄÅÄÄÄÄÄÅÄÄÄÄÄÄ
BLINK        ³128  ³ No  ³ ***

To display blinking characters in text mode, add BLINK to the foreground color (Defined in CONIO.H.)

CGA_COLORS (graphics mode)
In this table, the palette listings CGA0, CGA1, CGA2, and CGA3 refer to the four predefined four-color palettes available on CGA (and compatible) systems.

Paletteº Constant assigned to this color number (pixel value)
Number º       1        ³        2         ³        3
-------------------------Ø------------------Ø-----------------
 CGA0  º CGA_LIGHTGREEN ³ CGA_LIGHTRED     ³ CGA_YELLOW
 CGA1  º CGA_LIGHTCYAN  ³ CGA_LIGHTMAGENTA ³ CGA_WHITE
 CGA2  º CGA_GREEN      ³ CGA_RED          ³ CGA_BROWN
 CGA3  º CGA_CYAN       ³ CGA_MAGENTA      ³ CGA_LIGHTGRAY

You can select the background color (entry #0) in each of these palettes, but the other colors are fixed.


EGA_ COLORS (graphics mode)
Constant      ³Valueº Constant         ³Value
---------------Ø------------------------Ø-----
EGA_BLACK     ³  0  º EGA_DARKGRAY     ³ 56
EGA_BLUE      ³  1  º EGA_LIGHTBLUE    ³ 57
EGA_GREEN     ³  2  º EGA_LIGHTGREEN   ³ 58
EGA_CYAN      ³  3  º EGA_LIGHTCYAN    ³ 59
EGA_RED       ³  4  º EGA_LIGHTRED     ³ 60
EGA_MAGENTA   ³  5  º EGA_LIGHTMAGENTA ³ 61
EGA_LIGHTGRAY ³  7  º EGA_YELLOW       ³ 62
EGA_BROWN     ³ 20  º EGA_WHITE        ³ 63


directvideo

Controls video output

Declaration:  int directvideo

Remarks:
directvideo controls where your program's console output goes:

Value³ Meaning
-----Ø-------------------------------------
 0  ³ (Default) Goes via ROM BIOS calls
 1  ³ Goes directly to the video RAM

To use directvideo = 1, your system's video hardware must be identical to IBM display adapters.
If directvideo = 0, your console output will work on any IBM BIOS-compatible system.


text_info

Current text window information.

Used by the gettextinfo function.

struct text_info {
  unsigned char winleft;        /* left window coordinate */
  unsigned char wintop;         /* top window coordinate */
  unsigned char winright;       /* right window coordinate */
  unsigned char winbottom;      /* bottom window coordinate */
  unsigned char attribute;      /* text attribute */
  unsigned char normattr;       /* normal attribute */
  unsigned char currmode;       /* current video mode:
                                   BW40, BW80, C40, C80, or C4350 */
  unsigned char screenheight;   /* text screen's height */
  unsigned char screenwidth;    /* text screen's width */
  unsigned char curx;           /* x-coordinate in current window */
  unsigned char cury;           /* y-coordinate in current window */
};


text_modes

Enum: Standard video modes

Constant ³Value³ Text Mode

----------Ø-----Ø----------------------------------
LASTMODE ³ -1  ³ Previous text mode
BW40     ³  0  ³ Black and white       40 columns
C40      ³  1  ³ Color                 40 columns
BW80     ³  2  ³ Black and white       80 columns
C80      ³  3  ³ Color                 80 columns
MONO     ³  7  ³ Monochrome            80 columns
C4350    ³ 64  ³ EGA and               43-line
        ³     ³ VGA                   50-line


_wscroll

Enables or disables scrolling in console I/O
functions.

Declaration:  extern int_wscroll

Remarks:
_wscroll is a console I/O flag. You can use it to draw along the edges of a window without having the screen scroll.

Default = 1 (scrolling enabled)