A psychologist would like to determine whether there is a relation between depression and aging. It is known that the general population averages μ = 40 on a standardized depression test. The psychologist obtains a sample of n = 9 individuals who are all more than 70 years old. The depression scores for this sample are as follows.

50, 47, 41, 49, 44, 42, 43, 47, 48

On the basis of this sample, can the psychologist conclude that depression for elderly people is significantly different from depression in the general population? Use a two-tailed test at the 0.05 level of significance. (Round your answers to three decimal places.)

t=

The price of a stock is $40. The price of a one-year put with strike price $30 is $0.70 and a call with the same time to maturity and a strike of $50 costs $0.50. Both options are European.

(a) An investor buys one share, shorts one call and buys one put. Draw and comment upon the payoff of this portfolio at maturity as a function of the underlying price.

(b) How would your answer to (a) change if the investor buys one share, shorts two calls and buys two puts instead.

Lower-of-Cost-or-Market Inventory

Data on the physical inventory of Ashwood Products Company as of December 31 follows:

Quantity and cost data from the last purchases invoice of the year and the next-to-the-last purchases invoice are summarized as follows:

Required:

Determine the inventory at cost and also at the lower of cost or market, using the first-in, first-out method. Record the appropriate unit costs on the inventory sheet, and complete the pricing of the inventory. When there are two different unit costs applicable to an item, proceed as follows:

Insert the quantity and unit cost of the last purchase.

On the following line, insert the quantity and unit cost of the next-to-the-last purchase.

Total the cost and market columns and insert the lower of the two totals in the LCM column.

The first item on the inventory sheet has been completed as an example.

Materials Requirements Planning

QUESTION

An MRP exercise is being implemented over an 8-week period and the following relevant information is provided:

One (1) unit of A is made of two (2) units of B and three (3) units of C. One (1) unit of B is made up of three (3) units of D and two (2) units of E. One(1) unit of C is made up of two (2) units of B and two (2) units of D. Items A, C and E have one (1) week lead time. Items B and D have lead times of two (2) weeks. Assume that lot-for-lot (L4L) lot sizing is used for Items A, C and E and a lot size of 100 is used for items B and D. Items A and D have beginning inventories of twenty (20) and forty ( 40) units respectively; all other items have zero beginning inventory. We are scheduled to receive ten (10) units of item B in week two (2) and twenty (20) units of item D in week one (1). There are no other scheduled receipts.

1. Draw the product structure tree with low level coding. [5 marks]
2. Draw the corresponding time-phased diagram showing lead times to scale. [5 marks]
3. If fifty (50) units of A are required in Week eight (8), determine the necessary planned order releases for all components {five(5) schedules} [15 marks]

0. Introduction.

In this assignment you will implement a stack as a Java class, using a linked list of nodes. Unlike the stack discussed in the lectures, however, your stack will be designed to efficiently handle repeated pushes of the same element. This shows that there are often many different ways to design the same data structure, and that a data structure should be designed for an anticipated pattern of use.

1. Theory.

The most obvious way to represent a sequence of objects is simply to list them, one after the other, like this.

Note that the same objects often appear many times in a row. This is called a run of those objects. In the example sequence, there is a run of 2 a’s, a run of 3 b’s, a run of 1 c, a run of 2 a’s, and a run of 4 d’s. You can represent a sequence with runs by listing its objects, along with the number of times each object appears. For example, you can represent the sequence shown above like this.

Representing a sequence in this way is called run-length encoding. If a sequence has long runs, or many runs, then run-length encoding will represent it more efficiently than simply listing its objects. However, if a sequence has short runs, or few runs, then run-length encoding may represent it less efficiently, because extra space is needed to store the lengths of the runs.
      Since a stack is just a simple kind of sequence, you can use run-length encoding to implement it. In this assignment, you will write a Java class called RunnyStack that implements a stack which uses run-length encoding. Here are some examples of how it works. Suppose you push an object a on an empty RunnyStack. Then the stack will look like this, with a run of 1 a.

Now suppose you push b. The stack now looks like this, with a run of 1 b, and a run of 1 a.

If you push another b on the RunnyStack, then the length of the run on top of the stack is incremented, so the stack looks like this.

If you push yet another b, then the length of the run at the top of the stack would increase to 3. However, suppose that you pop the RunnyStack instead. Then the length of the run at the top is decremented, so that the stack looks like this.

If you pop the RunnyStack one more time, then the length of the run on top of the stack is decremented to 0. However, a run of 0 objects is like no run at all, so it vanishes, and the stack looks as it did after the first push.

Stacks with run-length encoding are used internally by some compilers and interpreters, because they often push the same objects over and over again.

2. Implementation.

You must write a class called RunnyStack that represents a stack. Your class must implement run-length encoding, as described previously. It must also hold objects of type Base, so it will look like this.

class RunnyStack<Base>
{
  ⋮
}

Your class must define at least the following methods, as described below. To simplify grading, your methods must have the same names as the ones shown here.

• public RunnyStack()

  Constructor. Make a new, empty instance of RunnyStack.

• public int depth()

  Return the depth of the stack: the sum of the lengths of all the runs it holds. This is not necessarily the same as the number of runs it holds, which is returned by the method runs.

• public boolean isEmpty()

  Test if the stack is empty.

• public Base peek()

  If the stack is empty, then throw an IllegalStateException. Otherwise, return the Base at the top of the stack.

• public void pop()

  If the stack is empty, then throw an IllegalStateException. Otherwise, decrement the length of the run on top of the stack. If this leaves a run of zero Base’s on top of the stack, then remove that run.

• public void push(Base base)

  If the stack is empty, then add a new run of one Base at the top of the stack. If the stack is not empty, then test if base is equal to the object in the run at the top of the stack. If it is, then increment the length of that run. If it isn’t, then add a new run of one base at the top of the stack. Note that base may be null.

• public int runs()

  Return the number of runs in the stack. This is not necessarily the same as its depth, which is returned by the method depth.

Important!！！！！！！！ Here are some hints, requirements, and warnings. First, all these methods must work using O(1) operations, so they are not allowed to use loops or recursions. You will receive no points for this assignment if you use loops or recursions in any way!
      Second, your RunnyStack class must have a private nested class called Run. You must use instances of Run to implement your stack. Each instance of Run represents a run of Base’s. You will receive no points for this assignment if you use arrays in any way! The class Run must have three private slots that have the following names and types. The slot base points to the Base that appears in the run. The slot length is an int that is the length of the run. The slot next points to the instance of Run that is immediately below this one on the stack, or to null. It must also have a private constructor that initializes these slots.
      Third, your push method must test non-null Base’s for equality using their equals methods. It must use the Java ‘==’ operator only for testing null Base’s. It is helpful to define an extra private method called isEqual that takes two Base’s as arguments, and tests if they are equal. If either Base is null, then isEqual uses ‘==’. If neither Base is null, then isEqual uses equals.
      Fourth, RunnyStack’s methods are not allowed to print things. If you were writing RunnyStack in the Real World, then it might be part of some larger program. You don’t know if that larger program should print things.

TEST.JAVA FILE AS FOLLOW:

//  The TRY-CATCH statements catch exceptions thrown by RUNNY STACK's methods,
//  so that the program can continue to run even if a method fails.
//
//  Tests have comments that show what they should print, and how many points
//  they are worth, for a total of 40 points.
//
//  Camembert is a soft French cheese. It may be runny. It can be stacked.
//

class Camembert
{
  public static void main(String [] args)
  {
    RunnyStack<String> s = new RunnyStack<String>();

    System.out.println(s.isEmpty());         //  true       1 point
    System.out.println(s.depth());           //  0          1 point
    System.out.println(s.runs());            //  0          1 point

    try
    {
      s.pop();
    }
    catch (IllegalStateException ignore)
    {
      System.out.println("No pop");          //  No pop     1 point
    }

    try
    {
      System.out.println(s.peek());
    }
    catch (IllegalStateException ignore)
    {
      System.out.println("No peek");         //  No peek    1 point
    }
 
    s.push("A");
    System.out.println(s.peek());            //  A          1 point
    System.out.println(s.depth());           //  1          1 point
    System.out.println(s.runs());            //  1          1 point

    System.out.println(s.isEmpty());         //  false      1 point

    s.push("B");
    System.out.println(s.peek());            //  B          1 point
    System.out.println(s.depth());           //  2          1 point
    System.out.println(s.runs());            //  2          1 point

    s.push("B");
    System.out.println(s.peek());            //  B          1 point
    System.out.println(s.depth());           //  3          1 point
    System.out.println(s.runs());            //  2          1 point

    s.push("B");
    System.out.println(s.peek());            //  B          1 point
    System.out.println(s.depth());           //  4          1 point
    System.out.println(s.runs());            //  2          1 point

    s.push("C");
    System.out.println(s.peek());            //  C          1 point
    System.out.println(s.depth());           //  5          1 point
    System.out.println(s.runs());            //  3          1 point

    s.push("C");
    System.out.println(s.peek());            //  C          1 point
    System.out.println(s.depth());           //  6          1 point
    System.out.println(s.runs());            //  3          1 point

    s.pop();
    System.out.println(s.peek());            //  C          1 point
    System.out.println(s.depth());           //  5          1 point
    System.out.println(s.runs());            //  3          1 point

    s.pop();
    System.out.println(s.peek());            //  B          1 point
    System.out.println(s.depth());           //  4          1 point
    System.out.println(s.runs());            //  2          1 point

    s.pop();
    System.out.println(s.peek());            //  B          1 point
    System.out.println(s.depth());           //  3          1 point
    System.out.println(s.runs());            //  2          1 point

    s.pop();
    s.pop();
    System.out.println(s.peek());            //  A          1 point
    System.out.println(s.depth());           //  1          1 point
    System.out.println(s.runs());            //  1          1 point

    s.pop();
    System.out.println(s.isEmpty());         //  true       1 point
    System.out.println(s.depth());           //  0          1 point
    System.out.println(s.runs());            //  0          1 point

    try
    {
      System.out.println(s.peek());
    }
    catch (IllegalStateException ignore)
    {
      System.out.println("No peek");         //  No peek    1 point
    }
  }
}

The International Air Transport Association surveyed business travellers to determine the assessment of international airports. The maximum possible rating was 10. Suppose a simple random sample of 50 travelers rated Miami Airport, and another simple random sample of 50 travelers rated Los Angeles airport. The answers were as follows.

Miami:

6     4     6     8     7     7     6     3     3     8     10     4      8

7     8     7     5     9     5     8     4     3     8      5     5      4

4     4     8     4     5     6     2     5     9     9      8      4     8

9     9     5     9     7     8     3     10     8     9     6

Los Angeles:

10     9     6     7     8     7     9      8     10     7     6     5     7

3     5     6     8     7     10     8     4     7      8     6     9     9

5      3     1     8     9      6      8     5     4      6    10    9     8

3     2     7      9     5     3     10     3     5     10    8

With α = 0.025, perform all the steps discussed in the course with the respective appropriate null and alternative hypotheses to determine that the two airports are highly competitive.

In 1974, Loftus and Palmer conducted a classic study demonstrating how the language used to ask a question can influence eyewitness memory. In the study, college students watched a film of an automobile accident and then were asked questions about what they saw. One group was asked, “About how fast were the cars going when they smashed into each other?” Another group was asked the same question except the verb was changed to “hit” instead of “smashed into.” The “smashed into” group reported significantly higher estimates of speed than the “hit” group. You, as a researcher wonder if Loftus and Palmer’s study is reliable, and repeats this study with a sample of FIU students and obtains the following data.

Your job is to determine if smashed into group reports higher speed than hit group. As you work on this problem, make sure to provide information for each of the eight steps we cover in Chapter 11 (Salkind) as well as the APA write-up you would see in a results section.

1. State the null and alternative hypotheses
2. Tell me your level of risk
3. Determine the best statistical test to use
4. Determine the value needed to reject the null hypothesis. Remember to calculate the correct degrees of freedom before finding the critical t-value! Note whether it is best to use the one-tailed or two-tailed test.
5. Compare the obtained and critical value
6. Decide whether you will retain the null hypothesis or …
7. Decide whether you will reject the null hypothesis
8. Finally, write up your results as you would see it in a results section of an empirical research paper. Make sure to include the means and SDs for smashed into and hit group (in miles). I do NOT need to see the effect size (Cohen’s D)
9. Was your obtained t-value positive or negative? Would it matter either way? With your discussion group, tell my why a positive or negative value is not important when it comes to your obtained value
10. What is more appropriate to use for your data set: the one-tailed t-Test or the two-tailed t-Test. Why? Would your APA write-up differ depending on which you used?
11. Why would it be easier to find significance using a p value of .05 than a p value of .01?
12. Finally (and this is the tough one), how would your results have differed with regard to steps 4 through 9 if you had used n rather than n – 1?

A large operator of timeshare complexes requires anyone interested in making a purchase to first visit the site of interest. Historical data indicates that 20% of all potential purchasers select a day visit, 50% choose a one-night visit, and 30% opt for a two-night visit. In addition, 40% of day visitors ultimately make a purchase, 50% of one-night visitors buy a unit, and 50% of those visiting for two nights decide to buy. Suppose a visitor is randomly selected and is found to have made a purchase.

How likely is it that this person made a day visit? (Round your answer to three decimal places.)

How likely is it that this person made a one-night visit? (Round your answer to three decimal places.)

How likely is it that this person made a two-night visit? (Round your answer to three decimal places.)

In part A of the synthesis of Lidocaine you will have to perform multiple extractions. Answer the following questions with the correct match. (bottom, top, aqueous layer, or ethereal layer)

In part C of the synthesis of Lidocaine you will have to perform multiple extractions. Answer the following questions with the correct match. (bottom or top)