Table of Contents

Part 1

Entries

Entry 1: August 31, 2012 Data

The creation of the program called size.c.

This is significant because you can determine your current character sizes, in bytes, based upon your current working console.

My code for the program below:
      #include<stdio.h>
      #include<stdlib.h>
      
      int main()
      {
      unsigned short int usi=0;
      unsigned int ui=0;
      unsigned long int uli=0;
      unsigned long long int ulli=0;
      unsigned char uc=0;             // char is 8 bits (256 bits, 0-255)
      unsigned char carry=0;
      unsigned char quantity=0;
      quantity =uc-1;
      uc=quantity+1;
      
      if      (uc<quantity)
              carry=1;
      else
              carry=0;
              
      //  printing values of short int
      printf("unsigned short is %d bytes\n", sizeof(unsigned short int));
      printf("usi low value is: %hx\n", usi);
      printf("usi high value is: %hx\n", (usi-1));
      printf("unsigned short int unique values is: %hx%.2hx\n", carry, uc);
      
      printf(" \n");
      
      //  printing values of int
      printf("unsigned int is %d bytes\n", sizeof(unsigned int));
      printf("ui low value is: %x\n", ui);
      printf("ui high value is: %x\n", (ui-1));
      printf("unsigned char unique values is: %x%.2x\n", carry, uc);
      
      printf(" \n");
      
      //  printing values of long int
      printf("unsigned long int is %d bytes\n", sizeof(unsigned long int));
      printf("uli low value is: %lx\n", uli);
      printf("uli high value is: %lx\n", (uli-1));
      printf("unsigned char unique values is: %lxx%.2lxx\n", carry, uc);
      
      printf(" \n");
      
      //  printing values of long long int
      printf("unsigned long long int is %d bytes\n", sizeof(unsigned long long int));
      printf("ulli low value is: %llx\n", ulli);
      printf("ulli high value is: %llx\n", (ulli-1));
      printf("unsigned char unique values is: %llxx%.2llxx\n", carry, uc);
      
      printf(" \n");
      
      //  printing values of char
      printf("unsigned char is %d bytes\n", sizeof(unsigned char));
      printf("uc low value is: %hhx\n", uc);
      printf("uc high value is: %hhx\n", (uc-1));
      printf("unsigned char unique values is: %hhx%.2hhx\n", carry, uc);
      
      return(0);
      }
 Concepts that do not make perfect sense currently are the %endings to each character.
 Presenting the unique values for each character based on demand for it.

Entry 2: September 5, 2012 Data

* What action or concept of significance, as related to the course, did you experience on this date?

 Created a program called pointers.c
The code for this program is below:
 #include<stdio.h>
 #include<stdlib.h>
 
 int main()
 {
 
      int a=12;
      int *b;
      b=&a;   // changing values can lead to segmentation faults ex) b=2600
            
 printf("a is located at 0x%X\n", &a);
 printf("b is located at 0x%X\n", &b);
 printf("b, when dereferenced, points to %d\n", *b);     // dereference= a value
 printf("b contains 0x%X\n", b);
 
 return(0);
 }

* Why was this significant?

 The significance of this program that is shows how the use of pointers work in use.

* What concepts are you dealing with that may not make perfect sense?

The "0x%", I don't fully understand what this is trying to accomplish.

* What challenges are you facing with respect to the course?

How exactly & work, and how to use them efficiently.

Entry 3: September 12, 2012 Discrete

What action or concept of significance, as related to the course, did you experience on this date?

Created my own program that showed the relations to my logic choosing, based around the thought of converse implication.
My code for my logic program: (called ctruth.c)
   #include <stdio.h>
   #include<stdlib.h>
    int main()
    {
      char logicor(char, char);
      int p = 0;
      int q = 0;
      int XNq(int p, int q);
      int result = 0;
      
       if ((p = 0) || (q = 0));
              result = 0;
       if ((p = 0) || (q = 1));
              result = 1;
      printf(" \n");
      printf("Your Converse Implication Truth Table.\n");
      printf(" \n");
      printf("P  |  Q  |  XNq  \n");
      printf("_  _  _  _  _  \n");
      
      q = 0;
      printf("%d  |  %d  |  %d \n", p, q, (p, q));    // all 0's
      
      q = 1;
      printf("%d  |  %d  |  %d \n", p, q, (q, p));    // when Q is false
      
      p = 0;
      printf("%d  |  %d  |  %d \n", q, p, (q, q));    // when Q is True
      
      p = 1;
      printf("%d  |  %d  |  %d \n", q, p, (p, 0));    // when P is False
      
      printf(" \n");
      
      printf("Please enter the value for P: \n");
      scanf("%d", &p);
      getchar();
      
      printf("Please enter the value for Q: \n");
      scanf("%d", &q);
      getchar();
      putchar()
      printf(" \n");
      
      if (p != q)
      {
              printf("Converse Implication Result.\n");
              printf("F  |  T  |  F \n", p, q, (q, p));
              printf(" \n");
      }
      else (p + !q);
      {
              printf("Other Results.\n");
              printf("T  |  T  |  T \n", p, q, (p, q));
              printf("T  |  F  |  T \n", q, p, (p, q));
              printf("F  |  F  |  T \n", q, p, (p, q));
              
      }
      int XNq(int p, int q);
      
      return (0);
      }

Why was this significant?

  This was significant because it was a project needed to be done for a grade.

What concepts are you dealing with that may not make perfect sense?

  The concepts of printf syntax of formatting a line.

What challenges are you facing with respect to the course?

  The understanding of pointers and how to use them effectively.

Entry 4: September 7, 2012

What action or concept of significance, as related to the course, did you experience on this date?

  Learned about pre-processing directories, including the #include and #define, #ifdef, #endif.

Why was this significant?

  These are used to make source programs easy to change and easy to compile in different execution environments. Directives in the source file tell the preprocessor to perform specific actions.

What concepts are you dealing with that may not make perfect sense?

  Which directories to use to execute a certain function correctly.

What challenges are you facing with respect to the course?

  Syntax involved with the typedef keyword.

Keywords

Class Pointer [C++], Data

Definition

Holds the address of another variable.

References

Data Structures Keyword Phase 2

Void Pointers

Definition

The void pointer is a generic pointer type. A pointer to void can store an address to any non-function data type, and, in C is implicitly converted to any other pointer type on assignment, but it must be explicitly cast if dereferenced inline.

References

Data Keyword 1 Phase 2 Phase 2

Dynamic Memory Allocation (Malloc/Free)

Definition

Dynamic memory allocation is the task of allocating a free chunk of memory specific to the size you predetermine in bytes, by using the malloc function. The chunk of memory is not always in the same location hence being “dynamic” instead of static. By using the “free” function, that will release the block of memory back to the system.

References

Demonstration (Malloc/Free)

/*
 * Sample code block
 */
#include<stdio.h>
#include<stdlib.h>
 
struct node {
        char value;
        struct node *next;
};
typedef struct node Node;
 
int main()
{
        Node *start, *tmp, *tmp2;       // Node pointers
        char input, i = 0;
 
        start = tmp = tmp2 = NULL;
 
        printf("Enter a value (-1 to end): ");
        scanf("%hhd", &input);
 
        while (input != -1)     // input does not equal -1
        {
                if (start == NULL)
                {
                        tmp = tmp2 = start = (Node *) malloc(sizeof(Node));     //allocating the size of the node
                        start->value = input;
                        start->next = NULL;     // Starts next element is null
                }
                else
                {
                        tmp->next = (Node *) malloc(sizeof(Node));
                        tmp->next->value = input;       //tmp next value= new node(user input)
                        tmp->next->next = NULL; //tmp next next =NULL
                        tmp = tmp->next;
                }
                printf("Enter a value (-1 to quit): ");
                scanf("%hhd", &input);
        }
 
        tmp = start;
        i=0;
        while (tmp != NULL)     //tmp does not equal NULL
        {
                printf("(%hhd)%hhd -> ",i, tmp->value); // print currrent value at node
                tmp = tmp->next;
                i = i + 1;
   }
        printf("NULL\n");
        printf("Enter node # to delete: ");
        scanf("%hhd", &input);
 
        tmp = start;
        if (input != 0)
        {
                for (i = 0; i < input -1; i++)
                        tmp = tmp->next;
                tmp2 = tmp -> next;
                        tmp -> next = tmp -> next -> next;
                tmp2 -> next = NULL;
                free (tmp2);
        }
        else
         {
                start = start -> next;
                tmp -> next = NULL;
                free(tmp);
        }
 
        tmp=start;
        i=0;
        while (tmp != NULL)     //tmp does not equal NULL
        {
                printf("(%hhd)%hhd -> ",i, tmp->value);  // print currrent value at node
                tmp = tmp->next;
                i = i + 1;
        }
        printf("NULL\n");
 
        return (0);
}

Alternatively (or additionally), if you want to demonstrate something on the command-line, you can do so as follows:

lab46:~$ cd src/data/Linked_List
lab46:~/src/data/Linked_List$ ls
lab46:~/src/data/Linked_List$ append  append.c  insert  insertion.c  link  linked.c  linkedlist.h  node  node.c  remove  remove.c
lab46:~/src/data/Linked_List$ ./remove
Enter a value (-1 to end): 1
Enter a value (-1 to quit): 2
Enter a value (-1 to quit): 3
Enter a value (-1 to quit): 4
Enter a value (-1 to quit): 5
Enter a value (-1 to quit): -1
(0)1 -> (1)2 -> (2)3 -> (3)4 -> (4)5 -> NULL
Enter node # to delete: 3
(0)1 -> (1)2 -> (2)3 -> (3)5 -> NULL
lab46:~/src/data/Linked_List$

Converse Implication, Discrete

Definition

For any two propositions P and Q, if Q implies P, then P is the converse implication of Q.

It may take the following forms:

  1. p⊂q
  2. Bpq
  3. p←q
 P  |  Q  | XNq  
 _  _  _  _  _  
 0  |  0  |  0 
 0  |  1  |  0 
 1  |  0  |  1 
 1  |  1  |  0

References

List any sites, books, or sources utilized when researching information on this topic. (Remove any filler text).

Discrete Keyword Phase 2

Nonconjunction/Not Both … And.

Definition

The relation among the components of such a proposition, usually expressed by AND or & or ·

References

Discrete Keyword 1 Phase 2 Phase 2

Left Projection

Definition

The left-shift operator causes the bit pattern in the first operand to be shifted to the left by the number of bits specified by the second operand. The value of a left-shift expression x « y is x * 2y

References

Demonstration (Left Projection)

/*
 * Sample code block
 */
#include <stdio.h>
 
int main()
{
  unsigned int i;
  int j;
  int input;
 
  i = 1;
 
printf("Enter a number to end your projection on: ");
scanf("%d", &input);
 
  for(j = 0; j < input ; j++)
{
    i = i << 1;
    printf("Left shift %d: %d(%X)\n", j, i);
}
 
return (0);
}

Alternatively (or additionally), if you want to demonstrate something on the command-line, you can do so as follows:

lab46:~$ cd ./src/discrete
lab46:~/src/discrete$ ls
big  bigl  bigl.c  bignum.c  bit  bitwise.c  ctruth  ctruth.c  inc  inc.c  sets.c  sort  sort.c
lab46:~/src/discrete$ ./bit
Enter a number to end your projection on: // Choose any number here \\ 9
Left shift 0: 2(0)
Left shift 1: 4(1)
Left shift 2: 8(2)
Left shift 3: 16(3)
Left shift 4: 32(4)
Left shift 5: 64(5)
Left shift 6: 128(6)
Left shift 7: 256(7)
Left shift 8: 512(8)
  Numbers in ( ) represent hexadecimal format, for when it becomes applicable at larger projection numbers.

Experiment 1

Question

What is the question you'd like to pose for experimentation? State it here.

Are there other escape sequences to meet a variance of needs, other than (\n) for a new line?

Resources

Collect information and resources (such as URLs of web resources), and comment on knowledge obtained that you think will provide useful background information to aid in performing the experiment.

Chapter 2: Types, Operators, and Expressions. The C Programming Language Book.

Hypothesis

Based on what you've read with respect to your original posed question, what do you think will be the result of your experiment (ie an educated guess based on the facts known). This is done before actually performing the experiment.

I believe the result of my experiment go as I intend it to end, by that I mean that the proper escape sequence will do its function.

State your rationale.

My rationale for this would be that my trust in the program will run correctly, not segmentation faults or anything controversial to the situation.

Experiment

How are you going to test your hypothesis? What is the structure of your experiment?

I am going to test my hypothesis by writing that program that will use some of the escape sequences. My data will show whether or not these escape sequences worked correctly or not. The structure of my program will be a line of printf statements using a certain escape sequence.

Data

Perform your experiment, and collect/document the results here.

   "The complete set of escape sequences is: "
\a alert (bell) character	\\ backlash
\b backspace			\? question mark
\f formfeed			\' single quote
\n newline			\" double quote
\c carriage return		\ooo octal number
\t horizontal tab		\xhh hexadecimal number
\v vertical tab
 Code for such program below: 
#include <stdio.h>
#include <stdlib.h>
 
main ()
{
int input;
 
  printf("Hello There\a -> alert (bell) character\n");
  printf("Hello There\b -> backspace\n");
  printf("Hello There\f -> formfeed\n");
  printf("Hello There\n -> newline\n");
  printf("Hello There\t -> horizontal tab\n");
  printf("Hello There\v -> vertical tab\n");
  printf("Hello There\\ -> backslash\n");
  printf("Hello There\? -> question mark\n");
  printf("Hello There\' -> single quote\n");
  printf("Hello There\" -> double quote\n");
 
return(0);
}
Results from running such code: 
Hello There -> alert (bell) character
Hello Ther -> backspace
Hello There
 |-> formfeed
Hello There
 |-> newline
Hello There      -> horizontal tab
Hello There
            |-> vertical tab
Hello There\ -> backslash
Hello There? -> question mark
Hello There' -> single quote
Hello There" -> double quote

Analysis

Was your hypothesis correct?

Yes, my hypothesis was correct.

Was your hypothesis not applicable?

My hypothesis was applicable, as shown above.

Is there more going on than you originally thought? (shortcomings in hypothesis)

The form-feed and the newline options produce the same result.

What shortcomings might there be in your experiment?

Not using all the escape sequences, for example \r (carriage return), this was not possible in my current experiment.

What shortcomings might there be in your data?

Not showing all the escape sequences shown in the table, as it was not possible in my current experiment.

Conclusions

What can you ascertain based on the experiment performed and data collected? Document your findings here; make a statement as to any discoveries you've made.

Based on the data collected I can say that escape sequences can be very useful, if used correctly, if not your statement will look awful. Discoveries made are that \f (form feed) and \n (newline) are relatively the same thing, they produce the same output. Form feed is now an outdated command, so no need to worry about its usage.