• On this date, I found out the proper syntax and usage of arrays in the C Programming language.
• Arrays are an essential part of programming, because they allow the programmer to input multiple similar variables into specific allocated memory, and from there the programmer can use that array to do many different things in the program.
• At the moment, the concept of arrays I am set with. I can't think of any problems that have come up.
• My understanding of arrays comes from C for Engineering, which is a little different because we used the C++ version of arrays, which gave me a little confusion at first, but now all is going well.

• On this date I finally grasped the concept of the data types and what I needed to program into the code to either accept them from the user or display them to the user.
• With this knowledge, I can easily program code that allows me to accept values and print values that are necessary for the program.
• The concept of printing characters in an array still confuse me, like the use of %s and %c.
• With the programming we did February 16, 2012, I began to understand what these mean and what I can do to print single characters instead of strings.

• On this date, the concept of using debugging programs was introduced.
• Using this method, I was able to find out where a logical error in a program is, and in some cases it can tell me how to fix it.
• This is very helpful, because logical errors occur often in programs, which doesn't stop the program from compiling. Using this strategy, I can find those logical errors quickly and correct them.
• I have used this a few times and it has helped quite a bit. It helped with some of the programs I had to write, and I was able to fix them easily.

• On this date, I learned how to take arguments input by the user, assign them to an array, and use them for multiple purposes.
• Using this method, I am able to print certain code, take the arguments, separate the characters, and use each as their ASCII numbers, and many other things.
• I used this in the first project, as well as some in class examples.
• My knowledge of using this method is still lacking a bit, but I am beginning to understand it more.

What would be printed if I replace the %u with the $d for an unsigned integer?

According to classes being taken, %d represents a signed integer, while %u represents an unsigned integer. The range for a signed integer data type is -2,147,483,647 to 2,147,483,646, while the range for an unsigned integer data type is 0 to 4,294,967,295.

I believe that the printed value will be the same ONLY if it is within the range of the signed integer data type. Ex. If the user inputs a value between 0 and 2,147,483,647, then it should print out fine, but if the value is greater than that range, then the value will “roll over” to the next integer in the signed integer data type, which would make the value a negative number.

Due to the data type only covering positive numbers (unsigned integer), it can go to larger numbers in the 4 bytes it is given for memory, but if it is printed as a signed integer, then it will only be able to print out half of the positive integers that it could as an unsigned integer, so it will go back over into the negative numbers until it satisfies the amount of digits it has.

To run this experiment, I am going to use the Lab46 terminal and create a program that will accept a value ranging from 0 to 4,294,967,295, which will be accepted as a unsigned integer. From there, the program will print the value back out as a signed integer using the %d command.

This is the code that I used:

#include<stdio.h>

int main()
{
        unsigned int integer;

        printf("Please input any integer between 0 and 4,294,967,295: ");
        scanf("%u\n", &integer);
        printf("The number you put into the program is: %d\n\n", integer);
        return(0);
}

This is the result:

lab46:~/src/cprog$ ./experiment1
Please input any integer between 0 and 4,294,967,295: 3015489756
1
The number you put into the program is: -1279477540

lab46:~/src/cprog$ 

Based on the data collected:

• My hypothesis was correct.
• My hypothesis was applicable because the number did roll over because it was too large to be included as a positive integer, so it just ran back as a negative number.
• Yes, much more is going on than I originally thought. I can mix it up.
• I tried to run the program and it did not work. It was able to run, and I fixed it.
• The data was what I was expecting.

When using an unsigned data type, it is possible to print that number as a signed data type, the only problem is that if it is larger than the range given, then it will just “roll over” until the entire number has been stored.

What would result from manipulating the “firstarray.c” program and replacing the “*4” with a “*3” and nothing else?

According to what I have learned so far, the purpose of the “*4” along with the function malloc is to allocate memory that the program can then store whatever it needs to in. This is one way to create an array. The “*4” in this program specifically multiplies the size of the char data type, which is one bit, and multiplies that by 4, leaving 4 bits of space that the program can store data in.

My best guess would be that the array will only have three char-sized “blocks” of memory that are available for storage. This will cause the fourth assignment in the array (*(array + 3)) to not be assigned to any block of memory in the array. This shouldn't cause any problems with the compiler, the program should run fine, still.

To perform this experiment, I have used a program from class and manipulated it, replacing the 4 with a 3 when sizing the array. The program then prints out what is left, and I believe that the program will print out a bunch of randomness when it gets to the fourth block of memory that was supposed to be created.

This is the program, minus the documentation:

#include<stdio.h>
#include<stdlib.h>

int main()
{
        char *value, i; //Declaring two integers: the pointer "value"
                        //and i as a char
        value = (char*)malloc(sizeof(char)*3);
                                              
        *(value+0) = 0;
        *(value+1) = 1;
        fprintf(stdout, "Please enter a value (-128-+127):");
        fscanf(stdin, "%hhd", &i);
        *(value+2) = i;
                        
        *(value+3) = (2*i)+3;
                              
        for(i=3; i>=0; i--)
        {
                printf("%hhd\n", *(value+i));
        }
        return(0);
}

These are the results of the program:

lab46:~/src/cprog/Opus/Opus1$ ./experiment2
Please enter a value (-128-+127):15
33
15
1
0
lab46:~/src/cprog/Opus/Opus1$ ./experiment2
Please enter a value (-128-+127):458
-105
-54
1
0
lab46:~/src/cprog/Opus/Opus1$ ./experiment2
Please enter a value (-128-+127):12
27
12
1
0
lab46:~/src/cprog/Opus/Opus1$ 

Based on the data collected:

• My hypothesis was incorrect.
• My hypothesis was applicable. When the memory was allocated, a little bit of “buffer” memory was saved, as well, which allowed the last value to be stored when it was compiled.
• I didn't think that there would be any more memory left to store that value in, but it seems that there is more to the allocation of memory than I thought.
• The chance of storing a variable in an array when the program doesn't specifically make the memory for it is one that I did not think would happen.
• The lack of memory allocation didn't stop the number from kicking down the array's door and walking right in!

Through this experiment, I realized that there is more to arrays and memory allocation than I thought. There is a chance that variables may be stored in buffer memory when making an array, and that is what happened in this experiment. I also learned that I need to read up on my arrays.

Is it possible to multiply things in an array and store the result in the array?

From what I have learned about arrays, arrays are capable of a lot of different functions, like storing related variables, and either reading them out or using them for another purpose. So far, arrays have been used to store values and re-arrange them, read them back out, to take variables from one function and use them in another, and many other purposes.

I believe that this is possible, because arrays store similar variables, even if they are combined in some way and stored back into it.

I will make a program that creates an array that will allow the user to store two integer numbers between one and one hundred into the array. From there, the program will call those two numbers from it, and multiply the two numbers together, then storing the third in the array. The array will then be printed.

The program for the experiment:

#include<stdio.h>
#include<stdlib.h>

int main()
{
        int storage1 = 0;
        int storage2 = 0;
        int *array;
        array = (int*)malloc(sizeof(int)*3);

        fprintf(stdout, "Please enter two numbers between 1 and 100:\n");
        fscanf(stdin, "%u", &storage1);
        fscanf(stdin, "%u", &storage2);
        *(array) = storage1;
        *(array+1) = storage2;
        *(array+2) = (*(array+1)) * (*(array));
        fprintf(stdout, "These are the numbers stored in the array:\n%u\n%u\n%u$
        return(0);
}

The results:

<cli> lab46:~/src/cprog/Opus/Opus1$ ./experiment3 Please enter two numbers between 1 and 100: 10 15 These are the numbers stored in the array: 10 15 150 lab46:~/src/cprog/Opus/Opus1$ ./experiment3 Please enter two numbers between 1 and 100: 100 100 These are the numbers stored in the array: 100 100 10000 lab46:~/src/cprog/Opus/Opus1$

Based on the data collected:

• My hypothesis was correct.
• My hypothesis was applicable.
• What I thought was basically what happened, although I did think that due to the fact that I had to use the “*” symbol in the arrays and for multiplication, I thought that there may be some confusion in the program that would have caused an error.
• The program didn't have a check for any numbers below one or above 100, even though the number could have been much, much greater than 100. (Not lower than one, because any number below zero doesn't technically exist for the unsigned integer data type)
• Had I put in a number that caused the result to be greater than the threshold for integer data types, the result would have been incorrect by mathematical terms, and so the program would not have looked as if it worked, although it was fully functional and correct.

Arrays can be very useful when it comes to storing numbers and variables that you may need later or in other functions. An array could be created to take multiple numbers and use these numbers to show different operations and what the result of these operations would be.

• On this day, I learned about unions and how they are used in programming.
• Unions use the ability to hold multiple variables of different data types in the same memory location and allow the program to call from the union when the variables are necessary.
• The downside to the use of unions is that when the program uses the first variable and stores something for use in the second variable, the union scraps the old value and inputs the new one in the union. Basically, the union uses “one space” of memory for all the variables in the union.
• When the program calls these variables, the variable is represented by the name of the union, a period, and then the name of the variable.
• EXAMPLE:

If the union is named value, and the variables are [float f, int x], then when called, the variables will be value.f for the float variable, and value.x for the int variable.

• On this day, I learned about the declaration typedef and what it's function is.
• The purpose of typedef is to allow the programmer to create new data type names for the program's variables.
• This allows the programmer to change data type names for organization purposes or to possibly shorten some data types.
• And example of this would be:

 **//typedef//** int length; 

This would cause the int length to shortened to just length:

 length max, min; 

• On this date, I coded one of the most important things in programming: AND, OR, and NOT logic gates in C++.
  
• By doing this, I learned more about what they do, how they are used, and how to combine them and create other logic gates.
  
• This helped me become better acquainted with C++ programming, which is another thing that I learned recently.
  
• It was difficult to comprehend at first, but once I sat down and went through what I had typed up to begin with, everything started to make sense.
  

• On this day, we began learning about C++ programming.
• C++ programming is seen as an addition to C programming. It is used for Object-Oriented coding.
• I learned about C++ in the C for Engineers class that I took in the fall, but what I am being taught now is much different, and I like it more.
• So far, C++ is fairly easy to understand and use. I think I will get the hang of the new stuff soon.

What is the difference between using the fgetc() function and the fscanf() function?

According to a wiki on the website http://www.cplusplus.com/reference/clibrary/cstdio/fscanf/, fscanf's purpose is: “Reads data from the stream and stores them according to the parameter format into the locations pointed by the additional arguments.” This means that fscanf takes a stream that is input and stores that stream into a variable with a specified data type. According to a similar wiki on the same website, the function fgetc's purpose is: “Returns the character currently pointed by the internal file position indicator of the specified stream. The internal file position indicator is then advanced by one character to point to the next character.” In other words, fgetc takes a string and returns whatever it is being pointed to, character by character, until the string ends. One can take a variable and assign it these values.

I think that these two do very similar things, but the main difference is that a programmer can determine a variable data type with fscanf, while fgetc will always return a character. I that they will do the same thing when the data type of the value in the fscanf function is char, but other than that, you will get different results.

I will create a program that accepts the same value through both fgetc and fscanf and assigns them to different variables of the same data type. Then, I will use some fprintf functions to print these values, once as a char, and once as an int.

Experiment:

#include<stdio.h>
#include<stdlib.h>
 
int main()
{
        int scanvalue;
        int fgetcvalue;
        fprintf(stdout, "Input one number twice: ");
        fscanf(stdin, "%d", &scanvalue);
        fgetcvalue = fgetc(stdin);
        fprintf(stdout, "FSCANFVALUE being printed as an integer: %d\n", scanvalue);
        fprintf(stdout, "FGETCVALUE being printed as an integer: %d\n", fgetcvalue);
        fprintf(stdout, "FSCANFVALUE being printed as a character: %d\n", scanvalue);
        fprintf(stdout, "FGETCVALUE being printed as a character: %d\n", fgetcvalue);
        return(0);
}

Result:

lab46:~/src/cprog/Opus/Opus2$ ./experiment4
Input one number twice: 10
FSCANFVALUE being printed as an integer: 10
FGETCVALUE being printed as an integer: 10
FSCANFVALUE being printed as a character: 10
FGETCVALUE being printed as a character: 10
lab46:~/src/cprog/Opus/Opus2$ ./experiment4
Input one number twice: 10 10
FSCANFVALUE being printed as an integer: 10
FGETCVALUE being printed as an integer: 32
FSCANFVALUE being printed as a character: 10
FGETCVALUE being printed as a character: 32
lab46:~/src/cprog/Opus/Opus2$ ./experiment4
Input one number twice: 4 
FSCANFVALUE being printed as an integer: 4
FGETCVALUE being printed as an integer: 32
FSCANFVALUE being printed as a character: 4
FGETCVALUE being printed as a character: 32
lab46:~/src/cprog/Opus/Opus2$ 

Based on the data collected:

• My hypothesis was not correct, it seems that the data type of the variable that the fgetc function is storing the input is what matters.
• My hypothesis was relevant, but the trouble that comes is when fgetc accounts for the spaces, which fscanf does not account for.
• There is more than I thought going on, the function accounts for the data type of the value that the input is being stored into, which I didn't think happened.
• Like I stated, all input is taken when running fgetc, which could cause a problem with the output.
• There don't seem to be any shortcomings in my data.

What this experiment helped me understand is that fgetc and fscanf are applicable when accepting input, but I should watch out for any extra input, like enter, space, backspace, etc.

When given two different arrays with different values in them, what would happen if you set one equal to the other?

According to what I have learned, an array, when set equal to another array, as a pointer, will only have the array point to the address of the other.

I think that the array that will be set equal to another array will point to the address of the other, changing what memory it holds to the same memory as the other array. I have used this method a lot, and, so far, all I have seen is this result. Testing it now!

I will create code that will take two arrays, with different values stored in them, and set one equal to the other, and then reverse them and set them equal to each other. I will print each of the arrays before and after this switch of values.

DA CODE:

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
        char *array1, *array2;
        int i;
        array1 = (char *) malloc (sizeof(char) * 4 );
        array2 = (char *) malloc (sizeof(char) * 4 );
 
        printf("Input a 4 letter word: ");
        for( i = 0; i <= 3; i++ )
        {
                *( array1 + i ) = fgetc( stdin );
        }
 
        for( i = 0; i <= 3; i++ )
        {
                printf("%c", *( array1 + i ) );
        }
 
        getchar();
 
        printf("\nInput a 4 letter word: ");
        for( i = 0; i <= 3; i++ )
        {
                *( array2 + i ) = fgetc( stdin );
        }
 
        for( i = 0; i <= 3; i++ )
        {
                printf("%c", *( array2 + i ) );
        }
 
        array1 = array2;
        array2 = array1;
 
        printf("\nArray1: ");
 
        for( i = 0; i <= 3; i++ )
        {
                printf("%c", *( array1 + i ) );
        }
 
        printf("\nArray2: ");
 
        for( i = 0; i <= 3; i++ )
        {
                printf("%c", *( array2 + i ) );
        }
 
        printf("\n");
        return 0;
}

The result:

lab46:~/src/cprog/Opus/Opus2$ ./experiment5 
Input a 4 letter word: Cavo
Cavo
Input a 4 letter word: Josh
Josh
Array1: Josh
Array2: Josh
lab46:~/src/cprog/Opus/Opus2$ ./experiment5
Input a 4 letter word: Josh
Josh
Input a 4 letter word: Cavo
Cavo
Array1: Cavo
Array2: Cavo
lab46:~/src/cprog/Opus/Opus2$ 

Based on the data collected:

• Was your hypothesis correct?

– My hypothesis was correct, the first time one was assigned to the other, it dropped it's previous memory assignment and pointed to the new one.

• Was your hypothesis not applicable?

– I believe my hypothesis was applicable.

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

– There doesn't seem to be more than I thought going on.

• What shortcomings might there be in your experiment?

– There weren't any shortcomings, FOR THE FIRST TIME, I MADE CODE AND IT RAN JUST AS I WANTED IT TO! NO PROBLEMS!

• What shortcomings might there be in your data?

– My data was correct and accounted for!

I can conclude that my knowledge of arrays has increased, and is pretty good, now. Probably due to the great amount of arrays and array passing in projects 2 and 3.

Perform the following steps:

Whose existing experiment are you going to retest? Provide the URL, note the author, and restate their question.]

– I will be retesting Robert Matsch's third experiment, asking what happens if one accidentally puts ' in instead of “.

– URL: http://lab46.corning-cc.edu/opus/spring2012/rmatsch/start#experiment_3

Evaluate their resources and commentary. Answer the following questions:

• Do you feel the given resources are adequate in providing sufficient background information?

– He stated one resource, the C ANSI book that was purchased for the class. I believe that this would give enough information about the experiment.

• Are there additional resources you've found that you can add to the resources list?

– The interwebs!

• Does the original experimenter appear to have obtained a necessary fundamental understanding of the concepts leading up to their stated experiment?

– I believe he has, it gave him many errors, so I believe that he could understand that it isn't a good thing to do. (I hope)

• If you find a deviation in opinion, state why you think this might exist.

– I have no objections. Everything seems to be in order!

State their experiment's hypothesis. Answer the following questions:

• Do you feel their hypothesis is adequate in capturing the essence of what they're trying to discover?

– Yeah, I believe that it covers anything they may see.

• What improvements could you make to their hypothesis, if any?

– I think that he could have added more explanation, but mainly a spellcheck! :x

Follow the steps given to recreate the original experiment. Answer the following questions:

• Are the instructions correct in successfully achieving the results?

– They are correct, there isn't much more one can do when testing to see if it works or not.

• Is there room for improvement in the experiment instructions/description? What suggestions would you make?

– I have no suggestions.

• Would you make any alterations to the structure of the experiment to yield better results? What, and why?

– I would have added the result of the working code as well, and I would have just attempted to run the incorrect code, just to show the reader what happens. That could give the reader more piece of mind on the matter.

Publish the data you have gained from your performing of the experiment here.

The code of the correctly done program:

#include <stdio.h>
 
int main()
{
        printf("Hello, World!\n");
        return 0;
}

the code of the incorrectly done program:

#include <stdio.h>
 
int main()
{
        printf('Hello, World!');
        return 0;
}

The result of the correctly done program, followed by the result of the incorrectly done program:

lab46:~/src/cprog/Opus/Opus2$ gcc -o retest retest.c
lab46:~/src/cprog/Opus/Opus2$ gcc -o retestwrong retestwrong.c
retestwrong.c:5:9: warning: character constant too long for its type
retestwrong.c: In function 'main':
retestwrong.c:5: warning: passing argument 1 of 'printf' makes pointer from integer without a cast
/usr/include/stdio.h:339: note: expected 'const char * __restrict__' but argument is of type 'int'
lab46:~/src/cprog/Opus/Opus2$ ./retest
Hello, World!
lab46:~/src/cprog/Opus/Opus2$ ./retestwrong
Segmentation fault
lab46:~/src/cprog/Opus/Opus2$ 

Answer the following:

• Does the data seem in-line with the published data from the original author?

– The data that I have seems nearly identical to the data that Rob had.

• Can you explain any deviations?

– There were no deviations.

• How about any sources of error?

– The only errors were the expected ones that came with only putting ' instead of “.

• Is the stated hypothesis adequate?

– The stated hypothesis was adequate, he seemed to know what the result would be.

Answer the following:

• What conclusions can you make based on performing the experiment?

– I concluded that when putting a ' symbol in for a “ symbol in printf statements, an error occurs. I wasn't sure if something else would happen, which is why I chose this experiment.

• Do you feel the experiment was adequate in obtaining a further understanding of a concept?

– Absolutely, this experiment helped me to determine the result of my curiosity of a different, but slightly similar, symbol replacing the quotations.

• Does the original author appear to have gotten some value out of performing the experiment?

–I believe he has gotten some value out of this experiment.

• Any suggestions or observations that could improve this particular process (in general, or specifically you, or specifically for the original author).

– I don't think there are any suggestions, seems pretty straight forward.

This is a sample format for a dated entry. Please substitute the actual date for “Month Day, Year”, and duplicate the level 4 heading to make additional entries.

As an aid, feel free to use the following questions to help you generate content for your entries:

• On this day, I learned how to create nested functions to achieve a set goal.
• It allowed me to complete a project, as well as showed me what is possible with functions.
• I had trouble figuring out how to work pointer functions, due to the use of pointers inside of them and passing them to each other.
• I understand it, now. The use of nested functions should be easier for me, now.

• On this date, I found out that I can use fscanf instead of fgetc to accept character input that I need to change into integer.
• This allows me to use something I am more familiar with to assign input to values.
• What doesn't quite make sense to me is the buffer, and how if the buffer has a random value, like enter from the last time it was pressed, it gets printed.
• The challenge I am facing with the course at the moment is catching up on all of my work!

• On this date, we learned about polymorphism.
• Polymorphism allows a program to redefine functions and use them for a different purpose.
• The idea makes sense, what doesn't make as much sense is how to implement it in programming.
• I am having trouble with C++ and most of what that includes.

• On this date, we learned about Templates.
• Templates are like blueprints of code. It contains something that can be made but isn't actually made in the template.
• I'm not sure how I would use this, it seems that it would be important, but how to write it, I have no idea.
• I think I will try to implement it a few times.

Will passing by reference work just as well as passing by value? Specifically, would they give me the same result?

Passing by reference is a method that, when looking at pointers, points one argument at the address of another. Passing by value allows the compiler to copy one or more values in one or more addresses into a function, and allows the function to use these values. The original variables that are used are not changed.

I believe that they won't give me the same result. What will most likely happen is using pass-by-reference will allow me to manipulate the value given and the value given will be saved, but the value will not be saved as I would have liked with pass-by-value.

In my experiment, I will create a running program that will use both methods for the same purpose. The program will have one function for performing passing-by-value; the main function will have the coding for passing-by-reference. I will perform the same change on the variables, and that will determine whether or not the same change takes place for both cases.

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

Code for the experiment:

#include <stdio.h>
#include <stdlib.h>
 
// Function to demonstrate passing-by-value
 
void passByValue( int val1, int val2 )
{
        int pbv1, pbv2;
        pbv1 = pbv1 + 5;
        pbv2 = pbv2 + 5;
}
 
int main()
{
        int pbv1 = 5, pbv2 = 10, pbr1 = 5, pbr2 = 10;
        printf("Values before adding 5:\n");
        printf("a: %d\nb: %d\nc: %d\nd: %d\n", pbv1, pbv2, pbr1, pbr2);
 
        passByValue( pbv1, pbv2 );
        pbr1 = pbr1 + 5;
        pbr2 = pbr2 + 5;
 
        printf("Values after adding 5:\n");
        printf("a: %d\nb: %d\nc: %d\nd: %d\n", pbv1, pbv2, pbr1, pbr2);
        return 0;
}

Results of the experiment:

lab46:~/src/cprog/Opus/Opus3$ ./experiment1 
Values before adding 5:
a: 5
b: 10
c: 5
d: 10
Values after adding 5:
a: 5
b: 10
c: 10
d: 15
lab46:~/src/cprog/Opus/Opus3$ 

Based on the data collected:

• Was your hypothesis correct?

– My hypothesis was correct, they did not have the same change in values.

• Was your hypothesis not applicable?

– My hypothesis was applicable, the variables that were passed by reference did change, but the variables that were passed by value did not remain changed, they went back to their original values.

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

– Not really, all that I thought would happen, did happen. This just helped me to confirm my understanding of passing variables in different ways.

• What shortcomings might there be in your experiment?

– I did not print what the value was in the function, so the value may have never changed. I am certain that it did, however.

• What shortcomings might there be in your data?

– There weren't any, really. Everything seemed to work and was accounted for.

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.

– I can now say that I fully understand the difference between passing-by-value and passing-by-reference. I was confused on what the differences were, and if they were both applicable in any case, but it seems that they aren't and I need to decide when either is more appropriate.

When using logic operators, can one use more than two (in an if statement)?

Logic operators consist of and, or, not, is equal to, etc. These logic operators are usually used to check one variable or compare two variables which determine whether or not a piece of code will run or not. These operators are represented, in code, by these characters:

• and: &&
• or: ||
• not or not equal to: !=
• is equal to: ==

I don't think that more than two logic operators can be used without any clarification of their separation (parenthesis separating them). I believe that this would cause confusion in the code, and the compiler would not read the code as it was intended to be read, therefore leading to a logical error, but not a syntax error.

I am going to create a block of code that will test this. The if block will only run if x and y are greater than 0 or less than 0.

Code for the experiment (the one that separates):

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
        int x = 0, y = 0;
 
        printf("The following program will test to see if the result of two input numbers, when multiplied or divided, \
\nwill return a positive or negative number.\nPlease input the first value: ");
        scanf("%d", &x);
        printf("\nPlease input the second value: ");
        scanf("%d", &y);
 
        if( x == 0 || y == 0 )
        {
                printf("The value is zero.\n");
        }
        else if( ( x > 0 && y > 0 ) || ( x < 0 && y < 0 ) )
        {
                printf("The value will be positive\n");
        }
        else
        {
                printf("The value will be negative\n");
        }
        return 0;
}

The result for this code (with parenthesis as separation) worked and printed this:

lab46:~/src/cprog/Opus/Opus3$ ./experiment2
The following program will test to see if the result of two input numbers, when multiplied or divided, 
will return a positive or negative number.
Please input the first value: -1

Please input the second value: -2
The value will be positive
lab46:~/src/cprog/Opus/Opus3$ ./experiment2
The following program will test to see if the result of two input numbers, when multiplied or divided, 
will return a positive or negative number.
Please input the first value: 1

Please input the second value: 2
The value will be positive
lab46:~/src/cprog/Opus/Opus3$ ./experiment2
The following program will test to see if the result of two input numbers, when multiplied or divided, 
will return a positive or negative number.
Please input the first value: -1

Please input the second value: 2
The value will be negative
lab46:~/src/cprog/Opus/Opus3$ ./experiment2
The following program will test to see if the result of two input numbers, when multiplied or divided, 
will return a positive or negative number.
Please input the first value: 1

Please input the second value: -2
The value will be negative
lab46:~/src/cprog/Opus/Opus3$ 

Code without separation:

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
        int x = 0, y = 0;
 
        printf("The following program will test to see if the result of two input numbers, when multiplied or divided, \
\nwill return a positive or negative number.\nPlease input the first value: ");
        scanf("%d", &x);
        printf("\nPlease input the second value: ");
        scanf("%d", &y);
 
        if( x == 0 || y == 0 )
        {
                printf("The value is zero.\n");
        }
        else if( x > 0 && y > 0 || x < 0 && y < 0 )
        {
                printf("The value will be positive\n");
        }
        else
        {
                printf("The value will be negative\n");
        }
        return 0;
}

The result without separation:

lab46:~/src/cprog/Opus/Opus3$ ./experiment2
The following program will test to see if the result of two input numbers, when multiplied or divided, 
will return a positive or negative number.
Please input the first value: 1

Please input the second value: 1
The value will be positive
lab46:~/src/cprog/Opus/Opus3$ ./experiment2
The following program will test to see if the result of two input numbers, when multiplied or divided, 
will return a positive or negative number.
Please input the first value: -1 

Please input the second value: -1
The value will be positive
lab46:~/src/cprog/Opus/Opus3$ ./experiment2
The following program will test to see if the result of two input numbers, when multiplied or divided, 
will return a positive or negative number.
Please input the first value: 0

Based on the data collected:

• Was your hypothesis correct?

– My hypothesis was incorrect. I should have known, seeing as how C programming is free-form.

• Was your hypothesis not applicable?

– It wasn't really applicable, I figured it out, and decided to double check my incorrectness-ocity-ism!

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

– Not really with this, it is a simple concept, I just messed up!

• What shortcomings might there be in your experiment?

– Well, at first, I had an error. I fixed it in the code and it ran properly.

• What shortcomings might there be in your data?

– There don't appear to be any shortcomings in my data.

Well, my understanding of how free-form coding works seems to have eluded me for a time. I have regained it, and now I shall use that power to further my exploration into the world of programming! YEAH!

Perform the following steps:

Whose existing experiment are you going to retest? Provide the URL, note the author, and restate their question.

– I decided to retest Josh Davis' experiment about multiplying an int value and a float value together. What would be the result?

– http://lab46.corning-cc.edu/opus/spring2012/jdavis34/start#experiment_3

Evaluate their resources and commentary. Answer the following questions:

• Do you feel the given resources are adequate in providing sufficient background information?

– He said he was able to create and run the program to provide a result for this experiment on his own from what he had learned in class. I believe it. He seemed to know what he was doing.

• Are there additional resources you've found that you can add to the resources list?

– I would use the C for Engineers class as a resource, because I vaguely remember learning about this, the answer just escapes me.

• Does the original experimenter appear to have obtained a necessary fundamental understanding of the concepts leading up to their stated experiment?

– I believe he does understand it.

• If you find a deviation in opinion, state why you think this might exist.

– No deviations in opinion, sir!

State their experiment's hypothesis. Answer the following questions:

• Do you feel their hypothesis is adequate in capturing the essence of what they're trying to discover?

– I believe that he has a thorough hypothesis, but I don't think it will go as he plans it to.

• What improvements could you make to their hypothesis, if any?

– I don't think that there are any improvements that you could make on his hypothesis. It seems very in depth.

Follow the steps given to recreate the original experiment. Answer the following questions:

• Are the instructions correct in successfully achieving the results?

– The instructions appear to be correct.

• Is there room for improvement in the experiment instructions/description? What suggestions would you make?

– I would suggest that he should have given some sort of result, and spaced it all out, made it a little easier to read. Just small things.

• Would you make any alterations to the structure of the experiment to yield better results? What, and why?

– I would not!

Publish the data you have gained from your performing of the experiment here.

DA CODE:

#include <stdio.h>
#include <stdlib.h>
 
int main()
{
        float x, z1;
        int y, z2;
 
        printf("Please input a number with a decimal value: ");
        scanf("%f", &x);
 
        printf("\nPlease input a whole number: ");
        scanf("%d", &y);
 
        z1 = x * y;
        z2 = x * y;
 
        printf("\nThe result stored in a float variable: %f\n", z1);
        printf("The result stored in an int variable: %d\n", z2);
 
        return 0;
}

DA RESULT:

lab46:~/src/cprog/Opus/Opus3$ ./retest2
Please input a number with a decimal value: 1.2

Please input a whole number: 2

The result stored in a float variable: 2.400000
The result stored in an int variable: 2
lab46:~/src/cprog/Opus/Opus3$ 

Answer the following:

• Does the data seem in-line with the published data from the original author?

– It is hard to determine, because he never actually showed any results. He used a function he created to multiply them together, which is cool, but I didn't do that.

• Can you explain any deviations?

– Mine was a little more organized and seemed to work better, since he said his did not compile.

• How about any sources of error?

– There are no errors in mine.

• Is the stated hypothesis adequate?

– The stated hypothesis is pretty good, had I not known ahead of time, I would have thought the same thing would happen.

Answer the following:

• What conclusions can you make based on performing the experiment?

– I can conclude that it is not necessary to add a specifier of how many decimals is needed when printing out a float value or assigning a float value.

• Do you feel the experiment was adequate in obtaining a further understanding of a concept?

– I do believe that this experiment was a good way of further understanding floats, since we didn't work with them much during the course.

• Does the original author appear to have gotten some value out of performing the experiment?

– It appears that he knew, then, that his understanding of variables and data types was not complete and not as in depth as he thought.

• Any suggestions or observations that could improve this particular process (in general, or specifically you, or specifically for the original author).

– I have no suggestions.