You are attempting to value a put option with an exercise price of $100 and one year to expiration. The underlying stock pays no dividends, its current price is $100, and you believe it has a 50% chance of increasing to $116 and a 50% chance of decreasing to $84. The risk-free rate of interest is 8%. Calculate the value of a put option with exercise price $100. (Do not round intermediate calculations. Round your answer to 2 decimal places.)

Value of a Put option?

Find the price of a bond with face value of $100 and $10 annual coupons that matures in 5 years, given that the continous compounding rate is 6%.

Suppose that the price of the same basket of goods at time 0 is PC0= 100 in country C and PD0= 90 in country D, so that the exchange rate is SCD0=10090. Inflation rates are expected to be 10% in country C and 21% in country D, over the foreseeable future.  

a) Does PP approximately predict an appreciation or depreciation of currency C?

b) What are the expected price levels in the two countries (i.e., PC1 and PD1 ) and the expected no-arbitrage exchange rate in one period (i.e., SC1 )? (Use the exact
form).

d) What is the expected no-arbitrage exchange rate two-years into the future?

Comprehensive Problem (TAX RETURN PROBLEM)

Barry and Connie, Husband and wife, are both age 24, and have two sons. Barry earned $51,000 and Connie earned $45,000 during 2020. They both paid $4,200 state income taxes, $12,000 federal income taxes, $5,500 property taxes, $14,600 to First Presbyterian Church, $600 to needy families, $6,400 interest on their mortgage, and $6,800 medical expenses. In addition, they had the following transaction:

a) They sold their personal residence for $170,000. Their basis in the residence was $104,000. They incurred $7,000 in selling expenses. They purchases a new residence six months later for $220,000.

b) Connie sold for $40,000 property she had inherited from her father in 2015. Her father's basis in the property was $15,000 and the fair market value on the date of death was $30,000.

c) They sold for $6,000 business property which they had acquired as a gift in 2017. The basis to the donor was $7,500 and the fair market value on the date of the gift was $7,000.

d) they exchanged 100 shares of Conway Corp. common stock, with a basis of $3,000, for 75 shares of Conway Corp. nonvoting common stock with a fair market value of 10,0000.

Determine Barry and Connie's lowest taxable income. Treat all income as ordinary income.

Arsenaux v. Arsenaux

Plaintiff wife sued for a separation from her husband on the grounds of abandonment. Alleging freedom from fault, she sought alimony, and additionally sought custody of a minor child and child support. The husband reconvened seeking a divorce on the grounds of adultery. In order to establish his claim, the husband sought to prove that his wife had become pregnant some two years following his vasectomy and had thereafter obtained an abortion. His effort was frustrated by the wife's successful assertion in the trial court that the medical records of her alleged abortion fell within the health care provider privilege for civil cases and her constitutional right to privacy.

The husband successfully appealed from the trial court's judgment in favor of the wife.' The Louisiana Supreme Court, in a four to three decision, reversed and held that the medical record in question is a communication under the explicit wording of the health care provider statute and, as such, should not be admitted. The court determined that the case did not fall within any of the statutory exceptions to the privilege. The court also based its decision upon a consideration of the wife's constitutional right to privacy.' The three dissenters argued that the wife had waived her privilege to have the evidence excluded by alleging freedom from fault.

Competency to Stand Trial

M’naghten Rule

HIPAA

Involuntary Commitment

Privilege communication

Tarasoff Rule

There are two types of consumers of Sony PlayStation video game consoles. The first type of consumer is highly eager to purchase the newest game consoles (early adopters). Their inverse demand is:

P = 600 - 0.01Q_E

After the first quarter the new PlayStations are on the market, early adopter demand goes to zero at any price. The second type of consumer is more sensitive to price and will be the same one quarter after the consoles are on the market (late adopters). Their inverse demand is:

P = 300 - 0.01QL
The marginal cost to the manufacturer is constant at $100.

a) If Sony initially sets the system price at $400, calculate their producer surplus.  (Round to the nearest whole number, do not use commas or dollar signs)

b) Do any second type customers purchase the new PlayStations at the initial release?  (yes or no)

c) Sometime after the initial release, the manufacturer lowers the price to $200. If only late adopters purchase the console at this later date, calculate producer surplus from these sales.  (same rounding rules)

(Think about why Sony has an incentive to charge a high relative price at initial release and then lower the price considerably sometime later.)

Prices of diamonds are determined by what is known as the 4 Cs: cut, clarity, color, and carat weight. The prices of diamonds go up as the carat weight increases, but the increase is not smooth. For example, the di?erence between the size of a 0.99 carat diamond and a 1 carat diamond is undetectable to the naked human eye, but the price of a 1 carat diamond tends to be much higher than the price of a 0.99 diamond. In this question we use two random samples of diamonds, 0.99 carats and 1 carat, each sample of size 23, and compare the average prices of the diamonds. In order to be able to compare equivalent units, we first divide the price for each diamond by 100 times its weight in carats. That is, for a 0.99 carat diamond, we divide the price by 99. For a 1 carat diamond, we divide the price by 100. The distributions and some sample statistics are shown below.43

Conduct a hypothesis test to evaluate if there is a di?er- ence between the average standardized prices of 0.99 and 1 carat diamonds. Make sure to state your hypotheses clearly, check relevant conditions, and interpret your re- sults in context of the data.

C++
---------------------------------------------

Do a comparison of a slow sort with Big O(n²) (selection sort, insertion sort, or bubble sort) and one faster sort of Big O(n * log n) (mergesort or quicksort). Count the number of moves (a swap counts as one move). With mergesort, you can count the range of the part of the array you are sorting (i.e. last-first+1). Use the code from the textbook (copy from the lecture notes) and put in an extra reference parameter for the count.

The array needs to be 10,000 items and the number of digits should be 4. Use the srand function to set the seed and rand function to generate the numbers (use the BubbleSort support code from the Examples, chapter 11). For instance:

srand(seed);

for (int x = 0; x < 10000; x++)

    ary[x] = rand() % 10,000;

Would fill the array. Note: do NOT use the "srand(time(NULL)):". You need to recreate the array to be resorted yet again. Note: you can use the sortSupport code on Canvas.

Call the slow sort first, print out the number of moves and the first 10 and last 10 values, fill the array again using the same seed, call the fast sort, and print the number of moves and the first 10 and last 10 values.

The run would look like:

The seed to use is: 39

Bubble sort had 25349145 swaps

The first 10 values: 0 0 0 3 3 6 6 7 7 9

The last 10 values: 9991 9991 9991 9992 9992 9994 9997 9997 9998 9998

Merge sort had 133616 moves

The first 10 values: 0 0 0 3 3 6 6 7 7 9

The last 10 values: 9991 9991 9991 9992 9992 9994 9997 9997 9998 9998
-------------------------------------------------------------------------------------------------------------

#include <cstdlib>
#include <iostream>
#include "sortSupport.h"
#ifndef SORTSUPPORT_CPP
#define SORTSUPPORT_CPP

using namespace std;

// Does seed first
// creates data for the array
template<class ItemType>
void makeArray(ItemType ary[], int max, int seed)
{
        srand(seed);
        for (int index = 0; index < max; index++)
                ary[index] = rand() % MAX_VALUE;
}

// prints the first 10 and last 10 items of an array
template<class ItemType>
void printEnds(ItemType ary[], int max)
{
        cout << "First 10: ";
        for (int index = 0; index < 10; index++)
                cout << ary[index] << " ";
        cout << endl << "Last 10: ";
        for (int index = max - 10; index < max; index++)
                cout << ary[index] << " ";
        cout << endl;
}
#endif
-----------------------------------------------------------------------------

#ifndef SORTSUPPORT_H
#define SORTSUPPORT_H
#include "bubbleSort.h"

const int MAX_VALUE = 10000;
const int MAX_SIZE = 10000;
const int MAX_DIGITS = 4;

template<class ItemType>
void makeArray(ItemType ary[], int max, int seed);

template<class ItemType>
void printEnds(ItemType ary[], int max);

#include "sortSupport.cpp"
#endif
------------------------------------------------------------------------------

#include <iostream>
#include <string>
const int MAX_SIZE = 50;
/** Merges two sorted array segments theArray[first..mid] and 
   theArray[mid+1..last] into one sorted array. 
@pre  first <= mid <= last. The subarrays theArray[first..mid] and    
theArray[mid+1..last] are each sorted in increasing order. 
@post  theArray[first..last] is sorted. 
@param theArray  The given array. 
@param first  The index of the beginning of the first segment in theArray. 
@param mid  The index of the end of the first segment in theArray;   
 mid + 1 marks the beginning of the second segment. 
@param last  The index of the last element in the second segment in theArray. 
@note  This function merges the two subarrays into a temporary    
array and copies the result into the original array theArray. */
template<class ItemType>
void merge(ItemType theArray[], int first, int mid, int last)
{   
ItemType tempArray[MAX_SIZE];  // Temporary array   
// Initialize the local indices to indicate the subarrays  
 int first1 = first;           // Beginning of first subarray   
int last1 = mid;               // End of first subarray  
 int first2 = mid + 1;          // Beginning of second subarray   
int last2 = last;              // End of second subarray   

// While both subarrays are not empty, copy the   
// smaller item into the temporary array  
 int index = first1;            // Next available location in tempArray  
 while ((first1 <= last1) && (first2 <= last2))   
  {      
// At this point, tempArray[first..index-1] is in order      
if (theArray[first1] <= theArray[first2])      
      {         
         tempArray[index] = theArray[first1];         
          first1++;      
       }    
     else     
       {        
        tempArray[index] = theArray[first2];        
         first2++;      
        }  // end if     
  index++;   
   }  // end while   

// Finish off the first subarray, if necessary   
while (first1 <= last1)   
  {      
    // At this point, tempArray[first..index-1] is in order     
  tempArray[index] = theArray[first1];      
  first1++;      
  index++;
   }  // end while  
 // Finish off the second subarray, if necessary   

while (first2 <= last2)   
{      
// At this point, tempArray[first..index-1] is in order      
tempArray[index] = theArray[first2];      
first2++;     
 index++;   
}  // end for   

// Copy the result back into the original array  
 for (index = first; index <= last; index++)      
theArray[index] = tempArray[index];
}  // end merge

/** Sorts the items in an array into ascending order. 
@pre  theArray[first..last] is an array. 
@post  theArray[first..last] is sorted in ascending order. 
@param theArray  The given array. 
@param first  The index of the first element to consider in theArray. 
@param last  The index of the last element to consider in theArray. */

template<class ItemType>
void mergeSort(ItemType theArray[], int first, int last)
{   
if (first < last)   
{      
// Sort each half      
int mid = first + (last - first) / 2; // Index of midpoint      

// Sort left half theArray[first..mid]     
 mergeSort(theArray, first, mid);      

// Sort right half theArray[mid+1..last]      
mergeSort(theArray, mid + 1, last);      

// Merge the two halves     
 merge(theArray, first, mid, last);  
 }  // end if

}  // end mergeSort

int main()
{   
std::string a[6] = {"Z", "X", "R", "K", "F", "B"};  
 mergeSort(a, 0, 5);   
   for (int i = 0; i < 6; i++)      
          std::cout << a[i] << " ";   
  std::cout << std::endl;

}  // end main

/* B F K R X Z  */
 

Price is the first element marketers adjust when sales are not as expected is this a smart strategy or not?