Which of the following production techs will exhibit a well-behaved solution to profit maximization that satisfies both the first and second order conditions in the short run when capital is fixed at some positive level?

1) q = f(K, L) = K^2 + ln(L)

2) q = f(K, L) = 2K + (1/2)L

3) q = f(K, L) = min (ln(K), ln(L))

4) q = f(K, L) = KL^2

Suppose you purchase one share of the stock of Red Devil Corporation at the beginning of year 1 for $44.75. At the end of year 1, you receive a dividend of $2 and buy one more share for $48.75. At the end of year 2, you receive total dividends of $4 (i.e., $2 for each share), and sell the shares for $56.75 each. What is the time-weighted return on your investment? (Round your answer to 2 decimal places. Do not round intermediate calculations.)

Bond 1 has a 4%annual coupon rate, $1000 maturity value, n = 5 years, YTM = 4% (pays a $40 annual coupon at the end of each year for each of the 5 years and $1,000 maturity payment at the end of year 5).

Bond 2 is a zero couponbond with a $1000 maturity value, and n = 5 years; YTM= 4%. (pays no coupons; only a $1,000 maturity payment at the end of year 5)

a. For the Zero Coupon Bond 2 above,what will be your annual compound yield for your 5 year holding period if the bond is held until maturity. (Hint: PV is the price you calculated for Bond 2and FV is the bond’s maturity value of $1,000 and n is the 5 year holding period; solving for i) (see formulas below).

Hint Recall: Annual Compound Yield = {[FV / PV] ^ 1/n} - 1 or

In other words {[What you have at the end of 5 Years / What You Paid] ^1/n } - 1

n = your 5-year holding period.  

Annual Compound Yield for Bond 2 at End of Year 5 __________________

b. Suppose for the Coupon Bond 1 above, rates go down to 2% after you purchase the bond for the life of the bond. Thus, you have to invest each of your $40 coupon payments at a 2% rate, and hold the bond to maturity, receiving your $1,000 maturity value at the end of year 5.

            What will be your annual compound yield?

Hint: Recall FV of Bond Coupons Reinvested for 5 years = Coupon Payment (FVIFA 2%, 5)

ACY = { [(FV of Coupons +Maturity Value) / (Price of Bond)] ^1/n } - 1, where n = 5 years

Annual Compound Yield for Bond 1 at the End of Year 5____________

c. Explain why you received your desired annual compound return for the 5 year holding period for Bond 2 in a., but didn’t receive your desired Annual Compound Return for Bond 1 for your 5 year holding period in b.?

A solid hydrate of Ca(NO3)2 is to be analyzed (Ca(NO3)2 •XH2O). A sample of the hydrate is weighed in a clean, dry and covered crucible. When empty, the crucible and cover are heated to a constant weight of 30.2016 g. The mass of the crucible and sample is 33.2255 g. The crucible with sample is heated (to drive off the water of hydration) to a final constant weight of 32.2995 g

Table 1: Mass Data for the Analysis of a Hydrate

Heating # / Crucible Mass (g) / With Hydrate (g)(no heating) / With Anhydr. (g)

0 / - / 33.2255 / -

1 / 30.2115 / - / 32.6777  

2 / 30.2018 / - / 32.5888

3 / 30.2016 / - / 32.2997

4 / - / - / 32.2995

Calculate the following from the data given above (using last value in each column = Constant Mass):

1. Mass of hydrate sample

2. Mass of water driven off by the heating

3. Mass of the anhydrous Ca(NO3)2

4. Percent water in the hydrate (from masses in #2 and #1)

5. Moles water in the sample (use 18.015 g/mol for water)

6. Moles Ca(NO3)2 in the sample

7. Ratio of moles H2O to moles Ca(NO3)2 (rounded to a whole number)

8. Formula of the hydrate

9. Percent water as determined from formula

10. % error assuming % water from formula to be the accepted value

Python

class DLLNode:
    """
    Class representing a node in the doubly linked list implemented below.
    """

    def __init__(self, value, next=None, prev=None):
        """
        Constructor
        @attribute value: the value to give this node
        @attribute next: the next node for this node
        @attribute prev: the previous node for this node
        """
        self.__next = next
        self.__prev = prev
        self.__value = value

    def __repr__(self):
        return str(self.__value)

    def __str__(self):
        return str(self.__value)

    def get_value(self):
        """
        Getter for value
        :return: the value of the node
        """
        return self.__value

    def set_value(self, value):
        """
        Setter for value
        :param value: the value to set
        """
        self.__value = value

    def get_next(self):
        """
        Getter for next node
        :return: the next node
        """
        return self.__next

    def set_next(self, node):
        """
        Setter for next node
        :param node: the node to set
        """
        self.__next = node

    def get_previous(self):
        """
        Getter for previous node
        :return: the previous node
        """
        return self.__prev

    def set_previous(self, node):
        """
        Setter for previous node
        :param node: the node to set
        """
        self.__prev = node


class DLL:
    """
    Class representing a doubly linked list.
    """

    def __init__(self):
        """
        Constructor
        @attribute head: the head of the linked list
        @attribute tail: the tail of the linked list
        @attribute size: the size of the linked list
        """
        self.head = None
        self.tail = None
        self.size = 0

    def __repr__(self):
        """
        iterates through the linked list to generate a string representation
        :return: string representation of the linked list
        """
        res = ""
        node = self.head
        while node:
            res += str(node)
            if node.get_next():
                res += " "
            node = node.get_next()
        return res

    def __str__(self):
        """
        iterates through the linked list to generate a string representation
        :return: string representation of the linked list
        """
        res = ""
        node = self.head
        while node:
            res += str(node)
            if node.get_next():
                res += " "
            node = node.get_next()
        return res

    ######### MODIFY BELOW ##########

    def get_size(self):
        """
        Gives the user the size of their linked list
        :return: [int] the size of the linked list
        """
        

    def is_empty(self):
        """
        Determines if the linked list is empty or not
        :return: [boolean] true if DLL is empty, false otherwise
        """
       
    def insert_front(self, value):
        """
        Inserts a value into the front of the list
        :param value: the value to insert
        """
       
    def insert_back(self, value):
        """
        Inserts a value into the back of the list
        :param value: the value to insert
        """
 

    def delete_front(self):
        """
        Deletes the front node of the list
        """

    def delete_back(self):
        """
        Deletes the back node of the list
        """

    def delete_value(self, value):
        """
        Deletes the first instance of the value in the list.
        :param value: The value to remove
        """



    def delete_all(self, value):
        """
        Deletes all instances of the value in the list
        :param value: the value to remove
        """
        pass

    def find_first(self, value):
        """
        Finds the first instance of the value in the list
        :param value: the value to find
        :return: [DLLNode] the first node containing the value
        """
        pass

    def find_last(self, value):
        """
        Finds the last instance of the value in the list
        :param value: the value to find
        :return: [DLLNode] the last node containing the value
        """
        pass

    def find_all(self, value):
        """
        Finds all of the instances of the value in the list
        :param value: the value to find
        :return: [List] a list of the nodes containing the value
        """
        pass

    def count(self, value):
        """
        Finds the count of times that the value occurs in the list
        :param value: the value to count
        :return: [int] the count of nodes that contain the given value
        """
        pass

    def sum(self):
        """
        Finds the sum of all nodes in the list
        :param start: the indicator of the contents of the list
        :return: the sum of all items in the list
        """
        pass


def remove_middle(LL):
    """
    Removes the middle of a given doubly linked list.
    :param DLL: The doubly linked list that must be modified
    :return: The updated linked list
    """
    pass

This is the testcases

import unittest
from DLL import DLL, DLLNode, remove_middle


class TestProject1(unittest.TestCase):

    def test_inserts(self):
        lst = DLL()
        lst.insert_front(1)
        lst.insert_front(2)
        lst.insert_front(3)
        lst.insert_back(4)
        lst.insert_back(5)

        self.assertEqual(lst.head.get_value(), 3)
        self.assertEqual(lst.tail.get_value(), 5)

        forward, backward = [], []
        head = lst.head
        while head is not None:
            forward.append(head.get_value())
            head = head.get_next()
        tail = lst.tail
        while tail is not None:
            backward.append(tail.get_value())
            tail = tail.get_previous()

        self.assertEqual(forward, [3, 2, 1, 4, 5])
        self.assertEqual(backward, [5, 4, 1, 2, 3])

    def test_accessors(self):
        lst = DLL()

        self.assertTrue(lst.is_empty())
        self.assertEqual(lst.get_size(), 0)

        for _ in range(5):
            lst.insert_front(1)

        self.assertTrue(not lst.is_empty())
        self.assertEqual(lst.get_size(), 5)

        for _ in range(3):
            lst.delete_front()

        self.assertTrue(not lst.is_empty())
        self.assertEqual(lst.get_size(), 2)

    def test_deletes(self):
        def condense(linkedlist):
            res = list()
            node = linkedlist.head
            while node is not None:
                res.append(node.get_value())
                node = node.get_next()
            return res

        lst = DLL()
        inserts = [1, 4, 0, 10, 3, 7, 9]

        for x in inserts:
            lst.insert_back(x)

        lst.delete_front()
        inserts.pop(0)

        self.assertEqual(inserts, condense(lst))

        lst.delete_back()
        inserts.pop()

        self.assertEqual(inserts, condense(lst))

    def test_delete_value_all(self):
        def condense(linkedlist):
            res = list()
            node = linkedlist.head
            while node is not None:
                res.append(node.get_value())
                node = node.get_next()
            return res

        lst = DLL()
        insert = [1, 2, 3, 4, 5, 6, 1, 1, 2, 4, 1, 9]

        for i in insert:
            lst.insert_back(i)

        lst.delete_value(1)
        self.assertEqual(condense(lst), insert[1:])

        lst.delete_all(1)
        self.assertEqual(condense(lst), [2, 3, 4, 5, 6, 2, 4, 9])

    def test_finds(self):
        lst = DLL()
        inserts = [9, 16, 5, 58, 32, 1, 4, 58, 67, 2, 4]

        for i in inserts:
            lst.insert_back(i)

        first = lst.find_first(32)

        self.assertEqual(first.get_value(), 32)
        self.assertEqual(first.get_next().get_value(), 1)
        self.assertEqual(first.get_previous().get_value(), 58)

        last = lst.find_last(2)

        self.assertEqual(last.get_value(), 2)
        self.assertEqual(last.get_next().get_value(), 4)
        self.assertEqual(last.get_previous().get_value(), 67)

        list_of_58s = lst.find_all(58)

        self.assertEqual(len(list_of_58s), 2)
        for i in list_of_58s:
            self.assertEqual(i.get_value(), 58)

        first = list_of_58s[0]
        second = list_of_58s[1]

        self.assertEqual(first.get_next().get_value(), 32)
        self.assertEqual(first.get_previous().get_value(), 5)

        self.assertEqual(second.get_next().get_value(), 67)
        self.assertEqual(second.get_previous().get_value(), 4)

    def test_count_sum(self):
        lst = DLL()
        inserts = [1, 3, 1, 4, 5, 6, 1, 3, 8]

        for i in inserts:
            lst.insert_back(i)

        self.assertEqual(lst.count(1), 3)
        self.assertEqual(lst.sum(), 32)

    def test_remove_middle(self):
        def condense(linkedlist):
            res = list()
            node = linkedlist.head
            while node is not None:
                res.append(node.get_value())
                node = node.get_next()
            return res

        lst = DLL()
        inserts = [1, 2, 3, 4, 5]

        for i in inserts:
            lst.insert_back(i)

        new = remove_middle(lst)

        self.assertEqual(condense(new), [1, 2, 4, 5])


if __name__ == "__main__":
    unittest.main()

Thanks a lot!

A psychologist would like to examine the effects of different teaching strategies on the final performance of 6^th grade students. One group is taught using material presented in class along with outdoor discovery, one group is taught using material taught in class alone, and the third group is taught using only the outdoor discovery method. At the end of the year, the psychologist interviews each student to get a measure of the student’s overall knowledge of the material.

Use an analysis of variance with α = .05 to determine whether these data indicate any significant mean differences among the treatments (teaching strategies). Remember to 1) State the null hypothesis, 2) Show all of your calculations, 3) Make a decision about your null hypothesis, 4) Make a conclusion including an APA format summary of your findings (include a measure of effect size if necessary), and 5) Indicate what you would do next given your findings.

4. Gradient descent. Gradient descent is one of the most popular algorithms in data science and by far the most common way to optimise neural networks. A function is minimised by iteratively moving a little bit in the direction of negative gradient. For the two-dimensional case, the step of iteration is given by the formula xn+1 , yn+1 = xn, yn − ε ∇f(xn, yn). In general, ε does not have to be a constant, but in this question, for demonstrative purposes, we set ε = 0.1. Let f(x, y) = 3.5x 2 − 4xy + 6.5y 2 and x0 and y0 be any real numbers. (a) For all x, y ∈ R compute ∇f(x, y) and find a matrix A such that [3] A x y = x y − ε ∇f(x, y). Write an expression for xn yn in terms of x0 and y0 and powers of A. (b) Find the eigenvalues of A. [1] (c) Find one eigenvector corresponding to each eigenvalue. [2] (d) Find matrices P and D such that D is diagonal and A = P DP −1 . [1] (e) Find matrices Dn , P −1 and An . Find formulas for xn and yn. [4] (f) Suppose x0 = y0 = 1. Find the smallest N ∈ N such that xN yN ≤ 0.05. [3] (g) Sketch the region R consisting of those (x0, y0) such that xN ≥ 0, yN ≥ 0 and [4] xN yN ≤ 0.05, xN−1 yN−1 > 0.05, where N is the number found in part (f). Write an equation for the boundary of R. Which points of the boundary belongs to R and which do not?

I beg of anyone to answer this :)

Create a system which ends when the user wants it to. After a user has used this system, there is an option of another user using it. The system should ask whether you want to continue or not. Below is a sample of the input/output system.

Are you a student or a librarian?
Hit 1 for student and 2 for librarian.
$1
Enter Name: $William
How many books do you want to take?
$4
What books do you want to take?
Enter book ISBN no(Ex: 242424) // Let's assume we have a 6 digit ISBN number for this project. Put any number to test //your system.
$454092

$535212

$676685

$128976
William borrowed 4 books.
Hit 1 to continue 0 to end system
$1
Are you a student or a librarian?
Hit 1 for student and 2 for librarian.
$2
Enter Name: $Miss Benny
0 Lisa borrowed 1 books //format: student_id Student_name "borrowed" number_of_books "books"
1 William borrowed 4 books
Type student id for more info.
$ 0
Lisa borrowed 1 books
235633
Hit 1 to continue 0 to end system
$0

//There needs to be an array for studentid, student name, isbn index start #, isbn index end #, and libarian name

//This is also C++,

//If you need further information please specify in the comments and I will edit the problem as needed. I need this information ASAP please.

//The $ represents inputs made by the "user"

Create a system which ends when the user wants it to. After a user has used this system, there is an option of another user using it. The system should ask whether you want to continue or not. Below is a sample of the input/output system.

Are you a student or a librarian?
Hit 1 for student and 2 for librarian.
$1
Enter Name: $William
How many books do you want to take?
$4
What books do you want to take?
Enter book ISBN no(Ex: 242424) // Let's assume we have a 6 digit ISBN number for this project. Put any number to test //your system.
$454092

$535212

$676685

$128976
William borrowed 4 books.
Hit 1 to continue 0 to end system
$1
Are you a student or a librarian?
Hit 1 for student and 2 for librarian.
$2
Enter Name: $Miss Benny
0 Lisa borrowed 1 books //format: student_id Student_name "borrowed" number_of_books "books"
1 William borrowed 4 books
Type student id for more info.
$ 0
Lisa borrowed 1 books
235633
Hit 1 to continue 0 to end system
$0

//There needs to be an array for studentid, student name, isbn index start #, isbn index end #, and libarian name

This is also C++,

If you need further information please specify in the comments and I will edit the problem as needed. I need this information ASAP please.

The $ represents inputs made by the "user"

• Question 2

0 out of 2 points

• Question 3

0 out of 2 points

• Question 4

2 out of 2 points