Expert answer:8 pages or more written report on “I.T. PROJECT” w
Expert answer:Hi, I need help, 8-10 pages written report on your “I.T. PROJECT” The code size should be arround 500 lines.Select a project, I already submit a proposal which is attached as “the proposal of my project” but you can choose another topic if you want.please see the attach (the proposal of my project, samples and instruction)Choose a topic that is “deep”- Background information (Wiki, youtube, google scholar)- Read papers/materials (3 papers, one short, one long etc)Some topics in discussion relation to researchSome interesting topics(1) Scalar wave energy (2) Quantum computing (3) Natural language processing with cloud computing(4) Cyber-security and cognitive recognition (5) No-SQLRead 2-5 articles in CS research papers.(2) Select a project and submit a proposal. Done, but you can change it if you want Project Selection: Based on the personal interests and capability, student can focus on research, development, or review/survey. Research-Oriented Projects: Research work plus prototype of testing software systems.Development-Oriented Projects: Project must followed by software development standard. The code size should be arround 500 lines.Review/Survey-Oriented Projects: Read many research/development articles, write a review/survey and a simulation software to support your survey. Final report: 8-10 pages written report on your own work. Copied material from any places will receive an F. RESEARCH PROPOSAL TEMPLATEState the Problem (Abstract): Problem to solve including project goals.Literature review (Introduction): What have been done in the past?Aims and Solving Strategy (Planning): How do you solve this problem?Expected Outcomes: What you can get? And time line. References: (Papers you have cited in your proposal)When preparing doing a research you need to state a problem to solve. In the beginning, you are asked to choose three possible things you like to do research with. This is called the research area, aspect, or topic. Then you are asked to find some research papers related to one of the research topics.Literature review: such as background information. What is already known or unknown? (Set the scene.)Aims and Solving Strategy: You can restate your problem here. What do you want to know, prove, demonstrate, analyze, test, investigate or examine? List your project aims in a logical sequence.Expected Outcomes: How do you anticipate you will achieve these aims? Expected outcomes, significance or rationale Why is it important? What do you expect it will deliver? You can also add why the project is important. Highlight the benefits, positive expected outcomes or innovative applications of knowledge. Timetable
sample1___moetifinalprojectprogramminglanguage.doc
sample1___moetifinalprojectprogramminglanguage.doc
sample_1___moetifinalprojectprogramminglanguage.doc
sample_2_cloud_based_industry_solutions_project_reportaltafjunied_spii.docx
sample_3_self_driving_cars.pdf
instruction.docx
the_proposal_of_my_project.docx
Unformatted Attachment Preview
Sample 1
Organization of Programming Languages Final Project
April 18, 2005
UDCMoetiLisp Written Report
Contents
I)
Objectives
II)
Syntax and Semantics
III)
Methodology
IV)
System Description
V)
Conclusion
Appendices
I)
Objectives:
To create an arithmetic language called UDCMoetiLisp for
the UDC Spring 2005 Organization of Programming Language
class Final Project, taught by Professor Li Chen.
UDCMoetiLisp should be able to do the following arithmetic
operations:
➢ Addition
➢ Subtraction
➢ Multiplication
➢ Division
UDCMoetiLisp should have the ability to evaluate simple,
and complex expressions. A higher level programming
language should be used to implement UDCMoetiLisp.
UDCMoetiLisp will be different from any other arithmetic
language because it should accept expressions that are in a
particular format. This format should be as follows for a
simple expression:
( + 2 33 5 7 –13 )
N.B. The ‘+’ operator can be substituted with any of
the following operators:
▪
+
▪
–
▪
*
▪
/
N.B. Parentheses, operators, and operands should be
separated by spaces, and operators should follow
opening parenthesis at all times.
This format should be as follows for a complex expression:
( + 2 33 5 7 –13 ( + 6 7 88 –7 ( + 6 5 3 ) ) )
N.B. The ‘+’ operator can be substituted with any of
the following operators:
▪
+
▪
–
▪
*
▪
/
N.B. Parentheses, operators, and operands should be
separated by spaces, and operators should follow
opening parentheses at all times.
N.B. Questions on Part 2 of the handout are answered
in sections I, II, Appendix, V, and V, respectively.
II)
Syntax and Semantics:
-> = <(complex_expression)>
= A | B | C
-> |
-> { } |
{ }
-> |
= + | – | * | /
➢ In an assignment statement, id is assigned the value
of a complex expression in parentheses.
➢ An id can be any integer, and for readability, an
integer can be given any of the values of A, B, or C,
➢ A Complex expression can either be a simple
expression, or a simple expression followed by a
complex expression
➢ A simple expression can either be an operator followed
by any amount of numbers, or an operator followed by
any amount of numbers and a simple expression
➢ A number can be an id or an expression
➢ An op can be a +, -, *, / symbol
III) Methodology:
The implementation of UDCMoetiLisp is in C++, and it is
included in this report. It is attached in the appendix.
The implementation of UDCMoetiLisp consists of the
following five functions:
➢ main
➢ begin
➢ getInput
➢ evaluate
➢ isInt
The logic behind each of these functions is shown in the
their respective flowcharts that are attached in the
appendices.
IV)
System Description:
UDCMoetiLisp uses recursion to evaluate simple and
complex expressions that involve addition, subtraction,
division, and multiplication of both positive and negative
integers. In order to define an expression and sub
expressions, parentheses need to be used. Spaces need to be
used to distinguish between parentheses, operators and
operands.
Since the expression to be evaluated is entered as a
string, the problems of distinguishing between parentheses,
operands, and operators, and that of separating
parentheses, single-digit integers, and multi-digit
integers arose. The later problem was solved first, by
reading the expression to be evaluated, and outputting it
into a text output file called “expressions.txt”. Each time
a blank space was encountered, the end line command was
sent to the output file. This way, parentheses, operators,
single-digit integers, and multi-digit integers where
separated. The former problem of distinguishing between
parentheses, operands, and operators, was solved by reading
the separate strings from the text file “expressions.txt”,
and using the ASCII values of the characters in each string
to determine the strings’ value.
In the evaluation of simple expressions, the operand
found after the opening parenthesis is used. Only one
operand can be used. In order to enter a negative value,
the negative sign must be placed before the integer without
a space between them.
In the evaluation of complex expressions, the
innermost expression is evaluated first, using its operand.
After this has been done, this innermost expression is
replaced by the result of its evaluation. This process is
repeated recursively with expressions being evaluated and
replaced by the result of their evaluation, in order of
precedence. The innermost expression having the highest
precedence, and the outermost having the lowest.
UDCMoetiLisp is limited by its sensitivity to the use
of empty space. If a space is omitted or incorrectly
entered, either a wrong answer or an error message is
outputted. Another one of UDCMoetiLisp’s limitations is its
inability to check for empty spaces that have either been
omitted or incorrectly entered, and its subsequent
inability to correct these mistakes. This then places the
responsibility of input error detection on the user.
V)
Conclusion:
All the objectives of this Final Project were met.
After approximately 14 days of designing, implementing,
debugging, and preparing the written report, the project
was completed. If an expression is entered correctly,
UDCMoetiLisp will give out the correct answer.
Object oriented programming was not used in this
program because the extra benefits, like data abstraction,
easy code reusability and extensibility, ease of
modification were not needed. This code is to be used for
demonstrational purposes only. The use of functions was
sufficient enough to accomplish the most important task,
which was the implementation of recursion.
The future concern of UDCMoetiLisp is the inability of
this program to detect and fix, or prevent errors that will
occur because of its sensitivity to, and dependency on the
use of spaces, during input. All that UDCMoetiLisp will do
is detect errors, but it cannot fix, or prevent them, yet.
Appendix 1
Source Code:
#include
#include
using namespace std;
#include
#include
#include
void begin();// calls function that accepts the expression and one that evaluates the
expression
void getInput();// accepts string and writes it to a text file
bool isInt(int a);// typechecks operands
int evaluate();// returns what expression, or sub expression evaluates to
ifstream in(“expressions.txt”);
void main()
{
begin();// calls begin function
}
void begin()
{
getInput();// calls getInput function
int total = 0;
string data;
while (in)// while text file is not empty
{
in>>data;// receives parentheses, operators, and operands
if (data == “(“)// if expression starts with opening parenthesis
{
total = evaluate();//call evaluate and place what it returns into total
variable
break;
}
else// if expression does not start with opening parenthesis
{
cout<<"Error! Start with '(' followed by a space.n";// print error
message
return;
}
}
cout<<"Total is "<=48 && test[x]<=57) || test[x]==45)// if operand is
positive or negative
{
x++;
}
else// else operand is neither positive or negative
{
flag = false;// operand is not an integer
goto exit;// jump to label 2
}
}
}
exit:// label 2
return flag;// return whether or not operand is an interger
}
int evaluate()
{
string hi;
char* change;
int sum = 0;
int b = 0;
in>>hi;// get input from text file
if (hi == “+”)// if input is addition operator
b=1;
else if (hi == “-“)// if input is subtraction operator
b=2;
else if (hi == “*”)// if input is multiplication operator
b=3;
else if (hi == “/”)// if input is divisition operator
b=4;
else// if operator is anything else
{
cout<<"Error! Enter operator after '('.n";// Print error
message
//
break;
}
if (b==2 || b==3 || b==4)// if operator is '-', '*', or '/'
{
in>>hi;// accept operand from text file
change = (char*)hi.c_str();// convert operand from string to integer
sum=sum + atoi(change);// convert operand from string to integer
}
while (true)
{
in>>hi;// accept operand from text file
if (isInt(hi) == true)
{
if (b==1)// if operator is ‘+’
{
change = (char*)hi.c_str();// convert operand from string to pointer
to char array
sum=sum + atoi(change);// convert operand from string to integer
and add
}
else if (b==2)// if operator is ‘-‘
{
change = (char*)hi.c_str();// convert operand from string to pointer
to char array
sum=sum – atoi(change);// convert operand from string to integer
and subtract
}
else if (b==3)// if operator is ‘*’
{
change = (char*)hi.c_str();// convert operand from string to pointer
to char array
sum=sum * atoi(change);// convert operand from string to integer
and multiply
}
else if (b==4)// if operator is ‘/’
{
change = (char*)hi.c_str();// convert operand from string to pointer
to char array
sum=sum / atoi(change);// convert operand from string to integer
and divide
}
else// else if operator is something else
cout<<"Error! Wrong operator. n";// print error message
}
else
{
if (hi == "(")// if sub expresion is found
{
if (b == 1)// if operator is '+'
sum = sum + evaluate();// solve expression recursively
using addition
if (b == 2)// if operator is '-'
sum = sum - evaluate();// solve expression recursively
using subtraction
if (b == 3)// if operator is '*'
sum = sum * evaluate();// solve expression recursively
using multiplication
if (b == 4)// if operator is '/'
sum = sum / evaluate();// solve expression recursively
using division
}
else
{
if (hi == ")")// if end of expression, or sub expression is
found
{
//break;
return sum;// return the value of the expression, or
sub expression
}
else// if anything out of the ordinary is encountered
{
cout<<"Machine Error! n";// print an error message
sum = -9999999;// give sum a nonsense value
break;
}
}
}
}
return sum;// returns the value of –9999999 if there is an error
}
Appendix 2
main Function Flowchart
Start
main ()
begin ()
main ()
End
Appendix 3
begin Function Flowchart:
begin Function Flowchart
Start
getInput ()
true
Yes
read data
from text file
No
data = "("
error
message
Yes
evaluate ()
No
error
message
solution to
expression
End
Appendix 4
getInput Function Flowchart:
getInput Function Flowchart
Start
open text file for
input
accept input
from user
input is not
null
Yes
data = ' '
Yes
send end line
command to
text file
No
No
data = null
error
message
Yes
close txt file
End
No
send data to
text file
Appendix 5
isInt Function Flowchart:
isInt Function Flowchart
Start
flag = true
Yes
increment to next
character of data
flag = truel
Yes
character of
data = null
No
character of
data = digit
or '-'
No
No
Yes
flag = false
return value of
flag
End
Appendix 6
evaluate Function Flowchart:
evaluate Function Flowchart
Part 1
Start
Get data
from text
file
data =
"+"
data =
"-"
No
Yes
b=1
No
data =
"*"
Yes
Yes
b=2
b=3
No
data =
"/"
No
error
message
Yes
b=4
b =2|3|4
Yes
sum = sum
+ data
break
No
true
No
First
Link
Appendix 7
Function Relation Diagram:
evaluate Function Flowchart
Part 2
First
Link
true
Yes
Get data
from text
file
data is
integer
No
No
data =
"("
sum =
-999999
data =
")"
error
message
Yes
Yes
return sum
Yes
No
b=1
b=2
break
No
b=3
No
b=4
No
sum = um
+
evaluate()
b =1
No
b=2
b=3
Yes
Yes
Yes
sum =
sum - data
sum =
sum * data
sum = um
+ data
return sum
No
sum = um
+
evaluate()
End
No
sum = um
+
evaluate()
b=4
Yes
sum =
sum / data
No
sum = um
+
evaluate()
error
message
Sample 1
Organization of Programming Languages Final Project
April 18, 2005
UDCMoetiLisp Written Report
Contents
I)
Objectives
II)
Syntax and Semantics
III)
Methodology
IV)
System Description
V)
Conclusion
Appendices
I)
Objectives:
To create an arithmetic language called UDCMoetiLisp for
the UDC Spring 2005 Organization of Programming Language
class Final Project, taught by Professor Li Chen.
UDCMoetiLisp should be able to do the following arithmetic
operations:
➢ Addition
➢ Subtraction
➢ Multiplication
➢ Division
UDCMoetiLisp should have the ability to evaluate simple,
and complex expressions. A higher level programming
language should be used to implement UDCMoetiLisp.
UDCMoetiLisp will be different from any other arithmetic
language because it should accept expressions that are in a
particular format. This format should be as follows for a
simple expression:
( + 2 33 5 7 –13 )
N.B. The ‘+’ operator can be substituted with any of
the following operators:
▪
+
▪
-
▪
*
▪
/
N.B. Parentheses, operators, and operands should be
separated by spaces, and operators should follow
opening parenthesis at all times.
This format should be as follows for a complex expression:
( + 2 33 5 7 –13 ( + 6 7 88 –7 ( + 6 5 3 ) ) )
N.B. The ‘+’ operator can be substituted with any of
the following operators:
▪
+
▪
-
▪
*
▪
/
N.B. Parentheses, operators, and operands should be
separated by spaces, and operators should follow
opening parentheses at all times.
N.B. Questions on Part 2 of the handout are answered
in sections I, II, Appendix, V, and V, respectively.
II)
Syntax and Semantics:
-> = <(complex_expression)>
= A | B | C
-> |
-> { } |
{ }
-> |
= + | – | * | /
➢ In an assignment statement, id is assigned the value
of a complex expression in parentheses.
➢ An id can be any integer, and for readability, an
integer can be given any of the values of A, B, or C,
➢ A Complex expression can either be a simple
expression, or a simple expression followed by a
complex expression
➢ A simple expression can either be an operator followed
by any amount of numbers, or an operator followed by
any amount of numbers and a simple expression
➢ A number can be an id or an expression
➢ An op can be a +, -, *, / symbol
III) Methodology:
The implementation of UDCMoetiLisp is in C++, and it is
included in this report. It is attached in the appendix.
The implementation of UDCMoetiLisp consists of the
following five functions:
➢ main
➢ begin
➢ getInput
➢ evaluate
➢ isInt
The logic behind each of these functions is shown in the
their respective flowcharts that are attached in the
appendices.
IV)
System Description:
UDCMoetiLisp uses recursion to evaluate simple and
complex expressions that involve addition, subtraction,
division, and multiplication of both positive and negative
integers. In order to define an expression and sub
expressions, parentheses need to be used. Spaces need to be
used to distinguish between parentheses, operators and
operands.
Since the expression to be evaluated is entered as a
string, the problems of distinguishing between parentheses,
operands, and operators, and that of separating
parentheses, single-digit integers, and multi-digit
integers arose. The later problem was solved first, by
reading the expression to be evaluated, and outputting it
into a text output file called “expressions.txt”. Each time
a blank space was encountered, the end line command was
sent to the output file. This way, parentheses, operators,
single-digit integers, and multi-digit integers where
separated. The former problem of distinguishing between
parentheses, operands, and operators, was solved by reading
the separate strings from the text file “expressions.txt”,
and using the ASCII values of the characters in each string
to determine the strings’ value.
In the evaluation of simple expressions, the operand
found after the opening parenthesis is used. Only one
operand can be used. In order to enter a negative value,
the negative sign must be placed before the integer without
a space between them.
In the evaluation of complex expressions, the
innermost expression is evaluated first, using its operand.
After this has been done, this innermost expression is
replaced by the result of its evaluation. This process is
repeated recursively with expressions being evaluated and
replaced by the result of their evaluation, in order of
precedence. The innermost expression having the highest
precedence, and the outermost having the lowest.
UDCMoetiLisp is limited by its sensitivity to the use
of empty space. If a space is omitted or incorrectly
entered, either a wrong answer or an error message is
outputted. Another one of UDCMoetiLisp’s limitations is its
inability to check for empty spaces that have either been
omitted or incorrectly entered, and its subsequent
inability to correct these mistakes. This then places the
responsibility of input error detection on the user.
V)
Conclusion:
All the objectives of this Final Project were met.
After approximately 14 days of designing, implementing,
debugging, and preparing the written report, the project
was completed. If an expression is entered correctly,
UDCMoetiLisp will give out the correct answer.
Object oriented programming was not used in this
program because the extra benefits, like data abstraction,
easy code reusability and extensibility, ease of
modification were not needed. This code is to be used for
demonstrational purposes only. The use of functions was
sufficient enough to accomplish the most important task,
which was the implementation of recursion.
The future concern of UDCMoetiLisp is the inability of
this program to detect and fix, or prevent errors that will
occur because of its sensitivity to, and dependency on the
use of spaces, during input. All that UDCMoetiLisp will do
is detect errors, but it cannot fix, or prevent them, yet.
Appendix 1
Source Code:
#include
#include
using namespace std;
#include
#include
#include
void begin();// calls function that accepts the expression and one that evaluates the
expression
void getInput();// accepts string and writes it to a text file
bool isInt(int a);// typechecks operands
int evaluate();// returns what expression, or sub expression evaluates to
ifstream in(“expressions.txt”);
void main()
{
begin();// calls begin function
}
void begin()
{
getInput();// calls getInput function
int total = 0;
string data;
while (in)// while text file is not empty
{
in>>data;// receives parentheses, operators, and operands
if (data == “(“)// if expression starts with opening parenthesis
{
total = evaluate();//call evaluate and place what it returns into total
variable
break;
}
else// if expression does not start with opening parenthesis
{
cout<<"Error! Start with '(' followed by a space.n";// print e ...
Purchase answer to see full
attachment
How it works
- Paste your instructions in the instructions box. You can also attach an instructions file
- Select the writer category, deadline, education level and review the instructions
- Make a payment for the order to be assignment to a writer
- Download the paper after the writer uploads it
Will the writer plagiarize my essay?
You will get a plagiarism-free paper and you can get an originality report upon request.
Is this service safe?
All the personal information is confidential and we have 100% safe payment methods. We also guarantee good grades