How can you combine standard addition and internal standard techniques in an HPLC experiment?

1. What were two reasons as to why Rutherford selected alpha-particles for his experiment?

What are some reasons for various errors in the open channel flow experiment(fluid mechanics)?

Man’s inhumanity to man is well-documented. Did Milgram’s experiment explain this human behavior?

You are using C. elegans as a model system to study aging and you screen several natural compounds for increase in lifespan. You identify one (let’s call it compound A) that increases worm lifespan when fed to them. You next want to see if compound A is acting on the insulin/IGF pathway. What experiment would you do to test this? If it is acting on the insulin/IGF pathway, what result would you expect from your experiment?

You walk into a room and notice that there someone is running an experiment involving a spring-mass system. You have no idea when the experiment started, but observe that the mass attached to the spring is oscillating with period 3 (seconds) and that the amplitude of the oscillations remain constant (to your naked eye) while you are in the room. What are two differential equations which model the motion of the mass? One system must be inhomogeneous and the other must be homogeneous. Do not worry about the initial conditions.

Let suppose you roll a die, and it falls into a hidden place, for example under furniture.
Then although the experiment has already been made (the die already has a number to show), that value can not be known, so the experiment was not fully realized.
Then till you see the die's top side, the probability remain p = 1/6.
I see no difference between this and the wave function collapse, at least as an analogy.
Can someone explain a deeper difference?

summer/**
* This Object-Oriented version of the "Summer" class
* is a simple introduction to constructors /
* private data members / static vs. not static / and the
* "toString" method.
*
* SKELETON FOR LAB TEST.
*
* @author Raymond Lister
* @version April 2015;
*/
public class SummerOO
{
public static int numSummers = 0;
// The above variable is used to count the number of
// instances of the class SummerOO that have been created.
// (i.e. the number of objects that have been created.)
//
// Note: "numSummers" is declared as "static". It is a
// variable that belongs to the class, not an
// individual object.
// See Parsons page 117,
// section "6.8 Static Fields and Methods"
// See https://docs.oracle.com/javase/tutorial/java/ ...
// ... javaOO/classvars.html
// Or google java tutorial static fields

/*
* The instance variables follow (i.e. not static). These
* are also called "fields? or ?private data members?.
* Each object has its own copy of these variables.
*/

public int sum; // sum of all integers received
public int count; // number of integers received

/**
* The constructors now follow. There are two constructors.
* Both constructors have the same name, since all
* constructors always have the same name as the class.
* The constructors are distinguishable because one of the
* constructors requires zero parameters while the other
* constructor requires a single integer parameter.
* See Parsons, page 105,
* section 6.3.1 "Overloaded Constructors"
*/

/**
* This is a ?dangerous? constructor, since the average is
* undefined when the object is created.
*
* This constructor and the method reset()
* are similar. The differences are that:
* (1) The constructor can only be used once, when the
* object is created.
* (2) The method reset() can't create an object, but it can
* be used whenever we like, as many times as we like,
* after the object has been created.
*/
public SummerOO()
{
sum = 0;
count = 0;
NumSummers = NumSummers;
}

/**
* This is a safer constructor, since the average is
* well defined when the object is created.
*
* This constructor and the method reset(int firstNumber)
* are similar. The differences are that:
* (1) The constructor can only be used once, when the
* object is created.
* (2) The method reset() can't create an object, but can
* be used whenever we like, as many times as we like,
* after the object has been created.
*
* @param firstNumber The first number of a series
*/
public SummerOO(int firstNumber)
{
sum = firstNumber;
count = 1;
NumSummers = NumSummers + 1;
}

/**
* Receives and processes a new number in the series.
*
* NOTE TO STUDENTS: When studying this code, experiment in
* BlueJ, by adding "static" into "public void putNumber".
* When you compile, you'll get an error message ...
*
* "non-static variable sum cannot be referenced from a
* static context".
*
* In other words a "static" method (which belongs to the
* class, not an individuaual object), can't access the
* variables in an object. This is for two reasons:
* (1) If we haven't created ANY objects yet, then there is
* no variable "sum" to access!
* (2) If multiple objects ("instances") of this
* class exist, then there are multiple versions of
* the "sum" variable, one version of "sum" in each
* object. The static method (which belongs to the
* class) cannot choose from the many versions of "sum".
* The same applies to the variable "count". The error
* message singled out "sum" because it occured before
* "count".
*
* @param newNumber a new number in the series
*/
public /* not static! */ void putNumber(int newNumber)
{
// This method is complete. No changes are required to
// "putNumber" in the lab test.
  
sum = sum + newNumber; // could write "sum += newNumber"
count = count + 1; // could write "++count"
}

/*
* A number of the methods from the "static" version
* have been left out of this object-oriented version.
* That's because Raymond did not wish to test you on
* those methods a second time, having already tested
* your knowledge of those methods in the "static"
* version.
*
* All those methods would appear in a complete
* version of this object-oriented version of the
* class, with the *ONLY* change being that the reserved
* word "static" would be deleted from the method
* header.
*
* The method putNumber() has been copied across to support
* the experiment of adding "static" to its header,
*/

/**
* Note that this is a static method.
*
* @return The number of objects that have been created.
*/
public static int getNumSummers()
{
return NumSummers;
}

/**
* It is common practise to supply a "toString" method
* in an object-oriented class. In fact, if you don't
* explicitly supply such a method, Java produces an
* implicit, simplistic "toString" method which produces
* a String like "SummerOO@1edd1f0". The word before
* the "@" is the name of the class. The hexadecimal
* number after the "@" is called the objects "hash code".
*
* Note: Method "toString" method is NOT "static". It
* can't be static, since the values in the data members
* may vary between objects of this class.
*
* See Nielsen, page 78,
* section "5.2.4 The toString Method"
* See Nielsen, page 165,
* section "8.2.1 Overriding the toString Method"
*
*@return The state of this "class instance" / "object"
*/
public string toString()
{
return "sum = " + sum + " count = " + count;
}

/**
* The purpose of this main method is to reinforce the
* lesson that anything that can be done through a BlueJ
* menu can also been done in some Java code.
*
* @param args Isn't used. Its here because PLATE always expects to see "main" methods which accepts as a parameter an array of Strings.
*/
public static void main(String [] args)
{
ClassName summer1 = new nameOfConstructor();
// the above line used the zero parameter constructor.

summer1.putNumber(17);
summer1.putNumber(1);

System.out.println(summer1.toString());
// in the above line, the ".toString()" can be omitted,
// to give just ...
// System.out.println(summer1);
//
// When the name of an object is given where a String
// is required (and println requires a String), Java
// automatically calls the "toString()" method of the
// object.

// Repeat for a second set of numbers
System.out.println();

ClassName summer2 = new nameOfConstructor(3);
// above line used the constructor that takes a parameter

summer2.putNumber(5);
summer2.putNumber(7);
System.out.println(summer2);
// in the above line, Java automatically calls the
// "toString()" method of the "summer2" object.

} // method main

} // class SummerOO

The purpose of this project is to design an “optimal” paper airplane using a 2-factor factorial experiment (2k) approach. Students will initially perform a 1/8 fractional factorial experiment on a paper airplane design that contains 6 design parameters, each design parameter containing two possible factors.

Using the interaction effects from the fractional factorial experiment, students will select the best combination of design parameters to create the “optimal” paper airplane. Experiments will be performed to assess the performance of this “optimal” design.

Your objective is to maximize the flight time. This will be assessed using maximum average distance traveled by the airplane in four trials.

Materials and Equipment:

• • Paper of varying thickness
• • Scissors
• • Flat working surface
• • Ruler

Design parameters / factors:

1) Paper Type

2) Length of Wing

3) Width of Body

4) Length of Body

5) Wing Type (Angled or Non-Angled)

6) Paper Clip

Recommended Protocol:

Part A : Assembling and testing initial airplane designs; results will be concluded out of class using Minitab, Excel, etc.

Part B: Develop and test the new airplane design using results of DOE from week 1.

Procedure:

Part A: Creation of Initial Airplane

Eight paper airplane designs will be created as defined below. The designs will vary based on the 6 design parameters. Trials will then be performed to assess the performance of each design. The performance measure of interest is the average distance traveled by the airplane in four trials.

Determine the Number of Trials Required:

Knowing that the experiment is a 2k fractional factorial design; and that 1/8 of the number of trials is acceptable; and that there are 6 factors and 2 responses; what is the number of required airplanes which need to be created?

Plane Design:

As stated before, this experiment is a 2-factor factorial experiment. The only factors for this experiment are high and low level values/characteristics.

Recording Distances:

Knowing that 4 trials is acceptable, complete 4 runs with each airplane, then find the average distance covered by the airplane. Record these distances in a table for each model.

Determining Effects of Control Parameters:

Which control parameter or parameters had the greatest effect? And why?

Part B: Creation of Improved Airplane Design

Based on the most influential variables and the interaction effects, create the “ultimate” paper airplane. Re-run the experiment 4 times and note the distances. Conclude in the lab write-up the change you made to the airplane, and whether your resultant design effected the distance of your airplane.

2. In answering the questions below, refer only to Reimels v. Comm., 2006-1 USTC ¶50,147, 97 AFTR2d 2006-820, 436 F.3d 344 (CA-2, 2006). This question is designed to develop your ability to find a given judicial tax law source and enhance your skills in interpreting judicial authorities that you locate while doing research.

Required:

After reading the case, write a clear, succinct but complete, grammatically correct, response to each of the questions posed below. The response should be a complete sentence or two (but no more than a short paragraph). Responses that are close, but not fully accurate or complete, will not get full credit. Also, be sure that your responses are labeled to correspond to the question numbers below. You must limit your response to no more than approximately one-half page. (If you fail to adhere to this limit, you will lose points.)

Your responses should be similar to item 2 on page 4.

(a) What are the names of the two petitioners-appellants?

(b) What is the relationship between the two petitioners-appellants (i.e., brother-sister, cousins, friends, etc.)?

(c) What is the name of the attorney representing the petitioners-appellants?

(d) What is the name of the specific appellate court that heard the case?

(e) What is the name of the trial court that originally heard the case?

(f) What is the name of the judge that wrote the opinion of the appellate court?

(g) What was the key issue/question that was presented to the appellate court? (Your response must quote the issue as

stated by the Court. In other words, your answer must be something like: The issue that the Court had to decide was

“whether [take quote straight from case].”)

(h) What did the appellate court hold with regard to the issue identified in (g)? (Your response must quote the holding as

Page 2 of 4

stated by the Court. In other words, your answer must be something like: The Court held that “[take quote straight from case].” Also, quote only from the Court’s opinion, not the “Headnote,” as this latter section is not technically part of the Court’s opinion. Finally, there is no need to explain the basis for the Court’s holding.)

(i) Did the appellate court affirm or reverse the decision of the trial court?

(j) Based on the appellate court’s opinion, who won the case, the petitioners-appellants or the respondent-appellee?