Tag: Capstone

Design an op-code to allow
the following to be encoded in a
32-bit instruction: a)
14 instructions with one 22-bit
address; b) 720 instructions with
one 12-bit address and 5-bit
register number; c) 128 instructions
with two 12-bit addresses and 2-bit
register number.

For this assignment, utilize the “fw2” and “fwe” objects from the “Beginning.RData” data set. Complete the assignment by executing the following steps. Include relevant details for each model for all steps.
Create an appropriate simple correlation for the two pairs of data in fw2 and fwe. Demonstrate the simple correlation using the cor.test, and fit the data within a linear model using the lm() command. For use of the lm() command on the fw2 data, assume “flow” is the predictor term (i.e., x variable), and that “abund” is the response term (i.e., y variable). For use of the lm() command on the fwe data, assume “sfly” is the predictor term (i.e., x variable), and that “speed” is the response term (i.e., y variable). Provide a screenshot of the results in a Word document.
Explain the results of the correlations and the linear models for the fw2 and fwe data.
Create a linear model to represent the coefficients for the objects fw2 and fwe data. Use the Summary command to show the results of the simple regression analysis. Provide a screenshot of the results in a Word document.
Obtain the confidence intervals for the linear models created in step 3 for the for the fw2 and fwe data. Provide a screenshot of the results in a Word document.
Use the fitted() command to extract the model fitted values for the linear models created in step 3 for the for the fw2 and fwe data. Provide a screenshot of the results in your assignment Word document.
Using the resid() command, obtain the residuals for the linear models created in step 3 for the for the fw2 and fwe data. Provide a screenshot of the results in a Word document.
Create a plain text file (.txt) of all executed commands for the assignment.
Attachments:
3146454_1_428970-636871860142503894-beginning.rdata

Construct a concept map on topic “ethics in nursing “ concept map assessment will encourage you to illustrate the relationship between law and practice.The map should be well layered and detailed as shown in the example attached below. Make sure that the reference style used in the map is “Vancouver Style”, and as instructed in the brief attached below. Use peer reviewed articles and journals as references, not older than 2013.Use at least 10 references.
Attachments:
3146401_2_2820323A-8749-4119-900B-9005591C008B.png

1. Introduction: Provide an introduction to topic and state the importance of law and ethics in nursing practice (300 word)
2. Portfolio Entry 1: Include the ethical vignette (scenario situation). Reflect on your everyday practice and try to identify a situation which represented an ethical problem or dilemma. The situation may also involve relevant legal and/or professional issues which it may be appropriate to address.(500 words)
What is a vignette
The ethical vignette aims to highlight ethical and legal issues through a record of clinical interactions. We recommend that the ethical dilemma is from a real-life situation that you have experienced, however it may be a hypothetical case based on your reading of the topic. If you are using a real-life situation please make sure the names and details of the characters, environment and situation are not identifiable (i.e. provide psuedo-names). In order to write about the case youmust have a clear sense of the value of your ethical dilemma and form a clear picture of the case you wish to present. It is important to stick to the facts about the case.
The vignette ability to capture the ethical and legal issues comes from the structure, therefore it is important to divide into the sections including: introduction; case study; assessment of the ethical/legal issue; and plan. Each section will consist of a narrative describing the historical or social context of the ethical and/or legal issues. Consider what was especially challenging about the case and check if similar cases have been reported previously in the literature.
How to get started in writing your vignette/scenario:
Note the facts: who involved? What is the situation?
Identify the ethical issues: what is at stake? what values are in conflict?
At what point did you consider there was a ethical/legal problem/dilemma?
Brainstorm options available : what did they do? what could have been done?
It will be important to think about the message or lesson that the case will present throughout your portfolio.
When writing the vignette keep the case concise and focused. Avoid the use of jargon and abbreviations and use the same tense verbs throughout.
Attachments:
3146357_1_Ethic.docx

Business Management/Accounting
Look at your accounting ratios and financial management. Describe how your team is doing. Tell us about whether Big Al has loaned your team money and why that happened. Describe your income statement, balance sheet, and cash flow.
One team member should submit a one- to two-page Word document from your team addressing these questions. Be sure to use good sources, and include citations in the document as necessary.
Attachments:
3138999_1_Annual-Report.html
3138999_2_Week-5-Milestone.docx

Suppose a company wants to design a data warehouse to facilitate the analysis of movingvehicles in an online analytical processing manner. The company registers huge amountsof auto movement data in the format of (Auto ID, location, speed, time). Each Auto IDrepresents a vehicle associated with information (e.g., vehicle category, driver category),and each location may be associated with a street in a city. Assume that a street map isavailable for the city.(a) Design such a data warehouse to facilitate effective online analytical processing inmultidimensional space.(b) The movement data may contain noise. Discuss how you would develop a methodto automatically discover data records that were likely erroneously registered in thedata repository.(c) The movement data may be sparse. Discuss how you would develop a method thatconstructs a reliable data warehouse despite the sparsity of data.(d) If you want to drive from A to B starting at a particular time, discuss how a systemmay use the data in this warehouse to work out a fast route.

Create an “EmployeeDemo” class. In the main function, the program should ask the user the number of employee in the company and create a 2-dimensional dynamic array (number of employee by 4 weeks). Then, the program should ask user to enter each employee’s information and the amount of hours they worked weekly.The program shows a menu with employee name for user to choose which employee to display the following information:? How much the person totally made? How much of paycheck is regular pay? How much of paycheck is overtime pay

Unix Shell
In this project, you’ll build a simple Unix shell. The shell is the heart of the command-line interface, and thus is central to the Unix/C programming environment. Mastering use of the shell is necessary to become proficient in this world; knowing how the shell itself is built is the focus of this project.
There are three specific objectives to this assignment:
To further familiarize yourself with the Linux programming environment.
To learn how processes are created, destroyed, and managed.
To gain exposure to the necessary functionality in shells.
Overview
In this assignment, you will implement a
command line interpreter (CLI)
or, as it is more commonly known, a
shell
. The shell should operate in this basic way: when you type in a command (in response to its prompt), the shell creates a child process that executes the command you entered and then prompts for more user input when it has finished.
The shells you implement will be similar to, but simpler than, the one you run every day in Unix. If you don’t know what shell you are running, it’s probably
bash
. One thing you should do on your own time is learn more about your shell, by reading the man pages or other online materials.
Program Specifications
Basic Shell:
wish
Your basic shell, called
wish
(short for Wisconsin Shell, naturally), is basically an interactive loop: it repeatedly prints a prompt
wish>
(note the space after the greater-than sign), parses the input, executes the command specified on that line of input, and waits for the command to finish. This is repeated until the user types
exit
. The name of your final executable should be
wish
.
The shell can be invoked with either no arguments or a single argument; anything else is an error. Here is the no-argument way:
prompt> ./wish wish>
At this point,
wish
is running, and ready to accept commands. Type away!
The mode above is called
interactive
mode, and allows the user to type commands directly. The shell also supports a
batch mode
, which instead reads input from a batch file and executes commands from therein. Here is how you run the shell with a batch file named
batch.txt
:
prompt> ./wish batch.txt
One difference between batch and interactive modes: in interactive mode, a prompt is printed (
wish>
). In batch mode, no prompt should be printed.
You should structure your shell such that it creates a process for each new command (the exception are
built-in commands
, discussed below). Your basic shell should be able to parse a command and run the program corresponding to the command. For example, if the user types
ls -la /tmp
, your shell should run the program
/bin/ls
with the given arguments
-la
and
/tmp
(how does the shell know to run
/bin/ls
? It’s something called the shell path; more on this below).
Structure
Basic Shell
The shell is very simple (conceptually): it runs in a while loop, repeatedly asking for input to tell it what command to execute. It then executes that command. The loop continues indefinitely, until the user types the built-in command
exit
, at which point it exits. That’s it!
For reading lines of input, you should use
getline()
. This allows you to obtain arbitrarily long input lines with ease. Generally, the shell will be run in
interactive mode
, where the user types a command (one at a time) and the shell acts on it. However, your shell will also support
batch mode
, in which the shell is given an input file of commands; in this case, the shell should not read user input (from
stdin
) but rather from this file to get the commands to execute.
In either mode, if you hit the end-of-file marker (EOF), you should call
exit(0)
and exit gracefully.
To parse the input line into constituent pieces, you might want to use
strsep()
. Read the man page (carefully) for more details.
To execute commands, look into
fork()
,
exec()
, and
wait()/waitpid()
. See the man pages for these functions, and also read the relevant book chapter for a brief overview.
You will note that there are a variety of commands in the
exec
family; for this project, you must use
execv
. You should notuse the
system()
library function call to run a command. Remember that if
execv()
is successful, it will not return; if it does return, there was an error (e.g., the command does not exist). The most challenging part is getting the arguments correctly specified.
Paths
In our example above, the user typed
ls
but the shell knew to execute the program
/bin/ls
. How does your shell know this?
It turns out that the user must specify a path variable to describe the set of directories to search for executables; the set of directories that comprise the path are sometimes called the
search path
of the shell. The path variable contains the list of all directories to search, in order, when the user types a command.
Important: Note that the shell itself does not
implement
ls
or other commands (except built-ins). All it does is find those executables in one of the directories specified by
path
and create a new process to run them.
To check if a particular file exists in a directory and is executable, consider the
access()
system call. For example, when the user types
ls
, and path is set to include both
/bin
and
/usr/bin
, try
access(“/bin/ls”, X_OK)
. If that fails, try “/usr/bin/ls”. If that fails too, it is an error.
Your initial shell path should contain one directory: `/bin’
Note: Most shells allow you to specify a binary specifically without using a search path, using either absolute paths or relative paths. For example, a user could type the absolute path
/bin/ls
and execute the
ls
binary without a search path being needed. A user could also specify a relative path which starts with the current working directory and specifies the executable directly, e.g.,
./main
. In this project, you do not have to worry about these features.
Built-in Commands
Whenever your shell accepts a command, it should check whether the command is a built-in command or not. If it is, it should not be executed like other programs. Instead, your shell will invoke your implementation of the built-in command. For example, to implement the
exit
built-in command, you simply call
exit(0);
in your wish source code, which then will exit the shell.
In this project, you should implement
exit
,
cd
, and
path
as built-in commands.
exit
: When the user types
exit
, your shell should simply call the
exit
system call with 0 as a parameter. It is an error to pass any arguments to
exit
.
cd
:
cd
always take one argument (0 or >1 args should be signaled as an error). To change directories, use the
chdir()
system call with the argument supplied by the user; if
chdir
fails, that is also an error.
path
: The
path
command takes 0 or more arguments, with each argument separated by whitespace from the others. A typical usage would be like this:
wish> path /bin /usr/bin
, which would add
/bin
and
/usr/bin
to the search path of the shell. If the user sets path to be empty, then the shell should not be able to run any programs (except built-in commands). The
path
command always overwrites the old path with the newly specified path.
Redirection
Many times, a shell user prefers to send the output of a program to a file rather than to the screen. Usually, a shell provides this nice feature with the
>
character. Formally this is named as redirection of standard output. To make your shell users happy, your shell should also include this feature, but with a slight twist (explained below).
For example, if a user types
ls -la /tmp > output
, nothing should be printed on the screen. Instead, the standard output of the
ls
program should be rerouted to the file
output
. In addition, the standard error output of the program should be rerouted to the file
output
(the twist is that this is a little different than standard redirection).
If the
output
file exists before you run your program, you should simple overwrite it (after truncating it).
The exact format of redirection is a command (and possibly some arguments) followed by the redirection symbol followed by a filename. Multiple redirection operators or multiple files to the right of the redirection sign are errors.
Note: don’t worry about redirection for built-in commands (e.g., we will not test what happens when you type
path /bin > file
).
Parallel Commands
Your shell will also allow the user to launch parallel commands. This is accomplished with the ampersand operator as follows:
wish> cmd1 & cmd2 args1 args2 & cmd3 args1
In this case, instead of running
cmd1
and then waiting for it to finish, your shell should run
cmd1
,
cmd2
, and
cmd3
(each with whatever arguments the user has passed to it) in parallel,
before
waiting for any of them to complete.
Then, after starting all such processes, you must make sure to use
wait()
(or
waitpid
) to wait for them to complete. After all processes are done, return control to the user as usual (or, if in batch mode, move on to the next line).
Program Errors
The one and only error message. You should print this one and only error message whenever you encounter an error of any type:
char error_message[30] = “An error has occurredn”; write(STDERR_FILENO, error_message, strlen(error_message));
The error message should be printed to stderr (standard error), as shown above.
After
any
most errors, your shell simply
continue processing
after printing the one and only error message. However, if the shell is invoked with more than one file, or if the shell is passed a bad batch file, it should exit by calling
exit(1)
.
There is a difference between errors that your shell catches and those that the program catches. Your shell should catch all the syntax errors specified in this project page. If the syntax of the command looks perfect, you simply run the specified program. If there are any program-related errors (e.g., invalid arguments to
ls
when you run it, for example), the shell does not have to worry about that (rather, the program will print its own error messages and exit).
Miscellaneous Hints
Remember to get the basic functionality of your shell working before worrying about all of the error conditions and end cases. For example, first get a single command running (probably first a command with no arguments, such as
ls
).
Next, add built-in commands. Then, try working on redirection. Finally, think about parallel commands. Each of these requires a little more effort on parsing, but each should not be too hard to implement.
At some point, you should make sure your code is robust to white space of various kinds, including spaces () and tabs (
t
). In general, the user should be able to put variable amounts of white space before and after commands, arguments, and various operators; however, the operators (redirection and parallel commands) do not require whitespace.
Check the return codes of all system calls from the very beginning of your work. This will often catch errors in how you are invoking these new system calls. It’s also just good programming sense.
Beat up your own code! You are the best (and in this case, the only) tester of this code. Throw lots of different inputs at it and make sure the shell behaves well. Good code comes through testing; you must run many different tests to make sure things work as desired. Don’t be gentle — other users certainly won’t be.
Finally, keep versions of your code. More advanced programmers will use a source control system such as git. Minimally, when you get a piece of functionality working, make a copy of your .c file (perhaps a subdirectory with a version number, such as v1, v2, etc.). By keeping older, working versions around, you can comfortably work on adding new functionality, safe in the knowledge you can always go back to an older, working version if need be.
Link to project and test bench:https://github.com/remzi-arpacidusseau/ostep-projects/tree/master/processes-shell

Please assignment needs to be done on Nz standards nursing. please let me know how much it will cost me. thanks
Attachments:
3152615_1_2867369-1-nursing-assignment.docx

4 Pages Must be assigned to Dr. Siddharth Kishorbhai Mehta
You are speaking in a meeting with the hospital compliance officer and the hospital representative for Health Insurance Portability and Accountability Act of 1996 (HIPAA) team, and have been asked “How will we maintain patient privacy with our documents on the Internet?”
Use the university library, journals, and your experience to create a strategic plan for a 200-bed acute care facility that considers possible data privacy breaches and proposes effective methods to avoid them. Additionally, explain what is required by the Joint Commission, the Health Information on Technology for Economic and Clinical Health (HITECH) Act, and the HIPAA regulations that must be followed for the protection of individually identifiable health information.
Cite at least 4 peer-reviewed references published within the past 5 years
1.The document identifies and defines possible data privacy breaches.
2. Proposes effective methods to avoid privacy breaches. A minimum of 4 articles are cited. (Max 52.5 points)
3. Explain what is required by the Joint Commission, the Health Information on Technology for Economic and Clinical Health (HITECH) Act, and the HIPAA regulations that must be followed for the protection of individually identifiable health information.