text:
# Second Order Linear ODE Summary

## Second Order Linear D.E. Summary

Homogenous D.E.
$y''+ay'+by=0$.

Solve the Characteristic Equation: $\lambda^2+a\lambda+b=0$.
Case 1) Two real roots $\lambda_1,\lambda_2$: $\implies \boxed{y=c_1e^{\lambda_1x}+c_2e^{\lambda_2x}}$

Case 2) Real double root $\lambda$: $\implies \boxed{y=c_1e^{\lambda x}+c_2xe^{\lambda x}}$

Case 3) Complex Conjugate root $\lambda_1,\lambda_2=-\frac{a}{2}\pm iw$, where $w=\sqrt{b-\frac{a^2}{4}}$: $\implies \boxed{y=e^{-\frac{a}{2}x}(c_1\cos wx+c_2\sin wx)}$

Non-homogenous D.E.
General solution of non-homogenous D.E.: $\displaystyle y=y_h+y_p,$ where $y_h$ is the general solution of the homogenous equation, and $y_p$ is the particular solution (with no arbitrary constants).

Method of Undetermined Coefficients (Guess and try method)
$y''+p(x)y'+q(x)y=r(x)$.

Only works if $r(x)$ is polynomial, exponential, sine or cosine (or sum/product of these).

Polynomial: Try $y$=Polynomial (e.g. $y=Ax^2+Bx+C$ or $y=Bx+C$.)

Exponential ($e^{kx}$): Try $y=ue^{kx}$, where $u$ is a function of $x$.

Trigonometric ($\sin kx$ or $\cos kx$): Convert to complex differential equation by replacing $y$ with $z$, replace $\sin kx$/$\cos kx$ by $e^{ikx}$.

Try $z=ue^{ikx}$, where $u$ is a function of $x$. After solving for $z$, take real/imaginary part of $z$ for cosine/sine respectively.

Method of variation of parameters
$y''+p(x)y'+q(x)y=r(x)$.

[Step 1)] Solve the homogenous D.E. $y''+p(x)y'+q(x)y=0$.

Get solution of the form $y_h=c_1y_1+c_2y_2$.

[Step 2)]
Let $\displaystyle u=-\int\frac{y_2r}{W}\,dx$ and $\displaystyle v=\int\frac{y_1r}{W}\,dx$ where $W$ is the Wronskian $\displaystyle W=y_1y_2'-y_1'y_2.$

Particular solution: $y_p=uy_1+vy_2$.

General solution: $y=y_h+y_p$.

Forced Oscillations
Let $F_0$ be the amplitude of the driving (external) force. If $F_0=0$, by Newton’s Second Law, $m\ddot{x}=-kx$, hence $\displaystyle \boxed{\ddot{x}=-\omega^2 x},$
where $\omega=\sqrt{k/m}$. The value $\omega$ is called the natural frequency.

If $F_0\neq 0$, then $\displaystyle \boxed{m\ddot{x}+kx=F_0\cos\alpha t},$
where $\alpha$ is the driving (external) frequency.

At resonance (when $\alpha=\omega$), $\displaystyle \boxed{x=\frac{F_0t}{2m\omega}\sin(\omega t)}.$

## Author: mathtuition88

https://mathtuition88.com/

This site uses Akismet to reduce spam. Learn how your comment data is processed.


text:
Aptitude

1

I forgot the last digit of a 7 digit telephone number. If one randomly dial the final three digits after correctly dialling the four, then what is the chance of dialling the correct number?

a

1/1000

b

1/1001

c

1/999

d

1/990

It is given that last three digits are randomly dialled. Then each of the digit can be selected out of 10 digits in 10 ways.

Hence required probability

= 1/10 * 1/10 * 1/10

= 1/1000

2

A person starting with 64 rupees and making 6 bets, wins three times and loses three times, the wins and loses occurring in random order. The chance for a win is equal to the chance for a loss. If each wager is for half the money remaining at the time of the bet, then the final result is:

a

A gain of Rs 27

b

A loss of 37

c

Neither gain or a loss

d

A gain or a loss depending upon the order in which the wins and losses occur

As the win leads to multiplying the amount by 1.5 and loss leads to multiplying the amount by 0.5, we will multiply initial amount by 1.5 thrice and by 0.5 thrice (in any order).

The overall resultant will remain same.

So final amount with the person will be (in all cases):

=64(1.5)(1.5)(1.5)(0.5)(0.5)(0.5)= Rs 27

Hence the final result is: 64-27 =37

3

A magician holds one six-sided die in his left hand and two in his right. What is the probability the number on the dice in his left hand is greater than the sum of the dice in his right?

a

7/108

b

5/54

c

1/9

d

2/17

The only way to roll higher on one die is if the magicians rolls between 2 and 5, inclusive, with two dice. Where he to roll a six with two dice than there is no way he could eclipse that number by rolling one die.

Below is the probability of rolling a certain number with two dice.

‘2’ – 1/36

‘3’ – 2/36

‘4’ – 3/36

‘5’-  4/36

Now the only numbers a magician can roll with the one die and win is between 3 and 6, inclusive. The chances of rolling any are always 1/6.

Next, we have to combine the probability distribution relating to two dice with that relating to the one.

The chances of a magician rolling any given number with one die are 1/6. So let’s start with the lowest number he can roll: a ‘3.’ To win with this roll, he will have to roll a ‘2’ with two dice, the odds of which are 1/36. So .

So the chances of him rolling a ‘3’ with one die and winning are 1/216.

Let’s repeat this logic for the next roll, ‘4.’ Chances of rolling are 1/6. Only way a ‘4’ wins is if he rolls a ‘2’ or a ‘3’ with two dice.

Odds of rolling a ‘2’ with two dice  + odds of rolling a ‘3’ with two dice = . Combine this with the odds of rolling a ‘4’ ( which is 1/6): .

If he rolls a ‘5’ with one die, he can win if he rolls a ‘4’ with two dice, the probability is 3/36. He can also win if he rolls a ‘2’ or a ‘3’ with two dice, the number outcomes we just found: 3/36. So we add

Next, if he rolls a ‘6’ on one die, he can beat ‘2’ through ‘5’ with the two dice. Number of ways to roll a ‘5’ = 4/36. Combining this with the odds of rolling a ‘6’ on one die with the odds or rolling ‘2’, ‘3’, ‘4’, or ‘5’ with the two dice we get: 10/216.

You may be wondering why I left the denominator as 216. Well, this allows us to add up all the instances he can possibly win:

4

In a single throw of two dice , find the probability that neither a doublet nor a total of 8 will appear.

a

7/15

b

5/18

c

13/18

d

3/16

n(S) = 36

A = {(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)}

B = { (2, 6), (3, 5), (4, 4), (5, 3), (6, 2) }

Required probability = 10/36 = 5/18

Note: (4,4) occurs in both. Count once.

5

A division of a company consists of seven men and five women.  If two of these twelve employees are randomly selected as representatives of the division, what is the probability that both representatives will be female?

a

1/6

b

2/5

c

2/9

d

5/33

First, the denominator. We have twelve different people, and we want a combination of two selected from these twelve.  We will use the formula :

nC2 = (n(n-1))/2

which, for profound mathematical reasons we need not address here, is also the formula for the sum of the first (n – 1) positive integers.  Here

12C2 = (12*(11))/2 = 6 * 11 = 66

That’s the total number of pairs we could pick from the twelve employees.  That’s our denominator.

For the numerator, we want every combination of two from the five female employees.  That’s

5C2 = (5*(4))/2 = 5 * 2 = 10

That’s the  number of pairs of female employees we could pick from the five.  That’s our numerator.

probability = 10/66 = 5/33

6

There are 10 items in a box, out of which 3 are defective. 2 items are taken one after the other. What is the probability that both of them are defective?

a

4/60

b

3/60

c

2/60

d

Both A and B

probability = 3C2/10C2 = ((3!) / (2! * 1!))/((10!) / (8! * 2!)) = 1/15
1/15 * 4/4 = 4/60

format: plain


text:
Question types: Electron Pushing / Curved Arrow (MarvinJS)

qtype_easyomechjs
Maintained by Carl LeBlond
Javascript Curved Arrow / Electron Pushing question based on MarvinJS. Can be used to test and strengthen students knowledge of reaction mechanism, resonance and curved arrow notation. This plugin requires MarvinJS from Chemaxon.

Plugin translations

Number of strings defined by the plugin: 34


text:
3 edited title

Do Categorical Quotients andPreserve Covering Maps?

2 edited body

SETTINGS:

Let $C$ be a category with fiber products and $B$ be a closed subcategory of $C$ (i.e. $B$ contains any isomorphism of $C$, and any base change of any morphism in $B$ is also a morphism in $B$).

Let $T$ be the topology on $C$ associated to $B$ (i.e. $Cov T$ consists of universal effective epimorphic families {$f_{i}:U_{i}\to U$} in $C$ such that each $f_{i}$ is a morphism in $B$).

Moreover, assume that the topology $T$ satisfies the following two conditions:

Condition I

Let $f,g,h$ be arbitrary morphisms in $C$, and assume that $h=gf$ and $h$ is in $B$.

1. If $g \in B$, then $f \in B$.

2. If ${f} \in CovT$, then $g \in B$.

Condition II

For any family of maps {$f_{i}:U_{i}\to X$} in $C$ for which there exists "disjoint union" $\coprod_{i} U_{i}$, then the induced map $\coprod_{i}U_{i}\to X$ is in $B$ if and only if $f_{i} \in B$ for all $i$.

Under the situation above,

Let $R$ be a categorical equivalence relation on an object $U \in C$ such that the two canonical projections $\pi_{i}: R\to U$ ($i=1,2$) are both covering maps of $U$ in the topology $T$.

And assume that this categorical equivalence has $T$-quotient $X$. This means that there exists a categorical quotient $p:U\to X$ of $\pi_{i}:R\to U$ such that the induced morphism of associated sheaves (on $T$) $p_{\ast}:h_{U} \to h_{X}$ is a categorical quotient of $\pi_{i \ast}:h_{R}\to h_{U}$ in the category of sheaves of sets on $T$.

(Then, one can prove that $R \cong U\times_{X}U$.)

Now, this is my QUESTION:

Is the map $p:U\to X$ a covering map in $T$ ?

In other words, is $p$ a universal effective epimorphism and satisfying $p\in B$ ?

I could prove a "converse" statement i.e. if $p:U\to X$ is a covering map of the topology $T$, then $\pi_{i}: U\times_{X}U \to X$ U$($i=1,2$) is a categorical equivalence relation such that each$\pi_{i} \in CovT$and has$p$as a$T$-quotient. But I could not prove the statement in my question. Please give me any advice. 1 Categorical Quotients and Covering Maps Before asking a question, please let me write down settings. SETTINGS: Let$C$be a category with fiber products and$B$be a closed subcategory of$C$(i.e.$B$contains any isomorphism of$C$, and any base change of any morphism in$B$is also a morphism in$B$). Let$T$be the topology on$C$associated to$B$(i.e.$Cov T$consists of universal effective epimorphic families {$f_{i}:U_{i}\to U$} in$C$such that each$f_{i}$is a morphism in$B$). Moreover, assume that the topology$T$satisfies the following two conditions: Condition I Let$f,g,h$be arbitrary morphisms in$C$, and assume that$h=gf$and$h$is in$B$. 1. If$g \in B$, then$f \in B$. 2. If${f} \in CovT$, then$g \in B$. Condition II For any family of maps {$f_{i}:U_{i}\to X$} in$C$for which there exists "disjoint union"$\coprod_{i} U_{i}$, then the induced map$\coprod_{i}U_{i}\to X$is in$B$if and only if$f_{i} \in B$for all$i$. Under the situation above, Let$R$be a categorical equivalence relation on an object$U \in C$such that the two canonical projections$\pi_{i}: R\to U$($i=1,2$) are both covering maps of$U$in the topology$T$. And assume that this categorical equivalence has$T$-quotient$X$. This means that there exists a categorical quotient$p:U\to X$of$\pi_{i}:R\to U$such that the induced morphism of associated sheaves (on$T$)$p_{\ast}:h_{U} \to h_{X}$is a categorical quotient of$\pi_{i \ast}:h_{R}\to h_{U}$in the category of sheaves of sets on$T$. (Then, one can prove that$R \cong U\times_{X}U$.) Now, this is my QUESTION: Is the map$p:U\to X$a covering map in$T$? In other words, is$p$a universal effective epimorphism and satisfying$p\in B$? I could prove a "converse" statement i.e. if$p:U\to X$is a covering map of the topology$T$, then$\pi_{i}: U\times_{X}U \to X$($i=1,2$) is a categorical equivalence relation such that each$\pi_{i} \in CovT$and has$p$as a$T\$-quotient.

But I could not prove the statement in my question.


text:
# The N=28 shell closure; from N=Z to the neutron drip line

Abstract : The evolution of the N=28 neutron shell closure is studied in the N=28 isotones from neutron drip line's $^{40}$Mg to N=Z doubly magic $^{56}$Ni. It is found that the N=28 closure vanishes at Z=12 in favor of a deformed ground state. For Z=14 and Z=16 closed shell and intruder configurations are almost degenerate, leading to highly mixed ground states and to very low lying excited 0$^+$ states. For Z$>$20 the intruder states are always above the closed shell ground states. We examine their structure and their possible existence as collective yrare bands of well defined particle-hole character.
Document type :
Preprints, Working Papers, ...

Cited literature [7 references]

https://hal.archives-ouvertes.fr/hal-00001364
Contributor : Frédéric Nowacki <>
Submitted on : Monday, March 29, 2004 - 11:51:06 AM
Last modification on : Thursday, April 23, 2020 - 2:26:10 PM
Long-term archiving on: : Friday, September 17, 2010 - 5:57:15 PM

### Citation

Etienne Caurier, Frédéric Nowacki, Alfredo Poves. The N=28 shell closure; from N=Z to the neutron drip line. 2004. ⟨hal-00001364v2⟩

Record views


text:
## Foam Cube Puzzle

After having solved the puzzle shown below a few times by combining six foam pieces to construct a hollow cube, I wondered if it had a unique solution. A simple brute-force search reveals it does. Source code: foam_cube.py

As a first step I digitalized all pieces seen above. Having an internal representation, I wrote a script which tries all possible rotations and reflections (as three-dimensional rotations can imply two-dimensional reflection) to try and construct a three-dimensional cube from the given pieces. Using short-circuit evaluation to not bother with already impossible solutions, the search space is narrow enough to not require any considerable computing time. The resulting unique solution modulo rotation is shown above; the top face is placed on the bottom right.

## Conky Clock

For a few months now, I have been a vivid user of the ArchLabs distribution which — in a recent release — added the system monitor Conky to display various pieces of information such as uptime, CPU usage and UTC time.

However, Conky does not statically produce a wall of text and plops it on your desktop; it periodically updates itself as to be able to display time-dependent information.
Furthermore, it allows to be fully configured through a simple `~/.config/conky/ArchLabs.conkyrc` file.

I wanted to display a useful time-dependent piece of information which does not require user interaction of any kind and found it — an analogue ASCII-art clock.

For installation, download conky_clock.py and add a `\${exec python <chosen_path>/conky_clock.py}` line to your conky configuration file.

## Truth

Proposition calculus deals with statements and the relation between statements, where each of them can only be in one of two states; $\vdash p \lor \lnot p$. Therefore, when working with finitely many connected propositions, one can algorithmically determine all possible truth values of all atomic and thus connected propositions.

Truth is command-line tool which was written to precisely perform those computations; computing a logical expression’s truth value. Download link: truth.py
A list of all supportet operators can be seen by invoking the tool with a `--help` flag.
This project was inspired by Albert Menne’s Einführung in die Logik1; the operator syntax used is similar to his, translated to be 7-bit-ASCII-compatible.

Truth can be used to either verify universally true statements, e.g. tertium non datur and a property of the replication, verum sequitur ex quodlibet.

```-(p&-p) <-> 1  ,  1 <- p
1 0010   1  1     1 1  0
1 1001   1  1     1 1  1
```

Though not only absolute truth, but also complete relational equivalence between two expressions can be shown.

```(p->q)|(r>-<s) <-> q|(r|s)&-(r&s)|-p
01 0 1 0 0 0   1  00 000 01 000 110
10 0 0 0 0 0   1  00 000 01 000 001
01 1 1 0 0 0   1  11 000 01 000 110
11 1 1 0 0 0   1  11 000 01 000 101
01 0 1 1 1 0   1  01 110 11 100 110
10 0 1 1 1 0   1  01 110 11 100 101
01 1 1 1 1 0   1  11 110 11 100 110
11 1 1 1 1 0   1  11 110 11 100 101
01 0 1 0 1 1   1  01 011 11 001 110
10 0 1 0 1 1   1  01 011 11 001 101
01 1 1 0 1 1   1  11 011 11 001 110
11 1 1 0 1 1   1  11 011 11 001 101
01 0 1 1 0 1   1  00 111 00 111 110
10 0 0 1 0 1   1  00 111 00 111 001
01 1 1 1 0 1   1  11 111 00 111 110
11 1 1 1 0 1   1  11 111 00 111 101```

Complete contravalence can also be shown.

```-(p/-p>-<0)|p->q<-r >-< p&-q&r
0 0110 1 0 101 01 0  1  001000
0 1101 1 0 110 01 0  1  111000
0 0110 1 0 101 11 0  1  000100
0 1101 1 0 111 11 0  1  100100
0 0110 1 0 101 01 1  1  001001
0 1101 1 0 010 00 1  1  111011
0 0110 1 0 101 11 1  1  000101
0 1101 1 0 111 11 1  1  100101```

1Menne, Albert: Einführung in die Logik. Bern: Franke, 1966. (= Dalp-Taschenbücher; 384 D)


text:
# parasys.net

Home > Error Propagation > Error Propagation Analysis

# Error Propagation Analysis

## Contents

Sign in 178 11 Don't like this video? If we now have to measure the length of the track, we have a function with two variables. Sometimes, these terms are omitted from the formula. Answer: we can calculate the time as (g = 9.81 m/s2 is assumed to be known exactly) t = - v / g = 3.8 m/s / 9.81 m/s2 = 0.387 http://parasys.net/error-propagation/error-propagation-data-analysis.php

Measurement Process Characterization 2.5. However, we want to consider the ratio of the uncertainty to the measured number itself. This is the most general expression for the propagation of error from one set of variables onto another. Further reading Bevington, Philip R.; Robinson, D.

## Error Propagation

Since the uncertainty has only one decimal place, then the velocity must now be expressed with one decimal place as well. outreachc21 17,692 views 15:00 XI 4 Error Propagation - Duration: 46:04. Uploaded on Jan 13, 2012How to calculate the uncertainty of a value that is a result of taking in multiple other variables, for instance, D=V*T. 'D' is the result of V*T.

Online Integral Calculator» Solve integrals with Wolfram|Alpha. By using this site, you agree to the Terms of Use and Privacy Policy. For example, the 68% confidence limits for a one-dimensional variable belonging to a normal distribution are ± one standard deviation from the value, that is, there is approximately a 68% probability Propagation Of Error Calculation Example Using the equations above, delta v is the absolute value of the derivative times the delta time, or: Uncertainties are often written to one significant figure, however smaller values can allow

PhysicsOnTheBrain 44,984 views 1:36:37 Uncertainty propagation by formula or spreadsheet - Duration: 15:00. Error Propagation For Addition For , and , so (9) For division of quantities with , and , so (10) Dividing through by and rearranging then gives (11) For exponentiation of quantities with (12) and If the statistical probability distribution of the variable is known or can be assumed, it is possible to derive confidence limits to describe the region within which the true value of http://physics.appstate.edu/undergraduate-programs/laboratory/resources/error-propagation Matt Becker 10,709 views 7:01 Measurements, Uncertainties, and Error Propagation - Duration: 1:36:37.

Principles of Instrumental Analysis; 6th Ed., Thomson Brooks/Cole: Belmont, 2007. Error Analysis Equation Square Terms: $\left(\dfrac{\delta{x}}{\delta{a}}\right)^2(da)^2,\; \left(\dfrac{\delta{x}}{\delta{b}}\right)^2(db)^2, \;\left(\dfrac{\delta{x}}{\delta{c}}\right)^2(dc)^2\tag{4}$ Cross Terms: $\left(\dfrac{\delta{x}}{da}\right)\left(\dfrac{\delta{x}}{db}\right)da\;db,\;\left(\dfrac{\delta{x}}{da}\right)\left(\dfrac{\delta{x}}{dc}\right)da\;dc,\;\left(\dfrac{\delta{x}}{db}\right)\left(\dfrac{\delta{x}}{dc}\right)db\;dc\tag{5}$ Square terms, due to the nature of squaring, are always positive, and therefore never cancel each other out. See Ku (1966) for guidance on what constitutes sufficient data2. http://mathworld.wolfram.com/ErrorPropagation.html Wolfram Web Resources Mathematica» The #1 tool for creating Demonstrations and anything technical.

## Error Propagation For Addition

In matrix notation, [3] Σ f = J Σ x J ⊤ . {\displaystyle \mathrm {\Sigma } ^{\mathrm {f} }=\mathrm {J} \mathrm {\Sigma } ^{\mathrm {x} }\mathrm {J} ^{\top }.} That look at this web-site Loading... Error Propagation paulcolor 29,438 views 7:04 Calculating Uncertainties - Duration: 12:15. Error Propagation Rules We leave the proof of this statement as one of those famous "exercises for the reader".

Foothill College. navigate to this website The uncertainty should be rounded to 0.06, which means that the slope must be rounded to the hundredths place as well: m = 0.90± 0.06 If the above values have units, Uncertainties can also be defined by the relative error (Δx)/x, which is usually written as a percentage. To fix this problem we square the uncertainties (which will always give a positive value) before we add them, and then take the square root of the sum. Error Propagation Uncertainty

Handbook of Mathematical Functions with Formulas, Graphs, and Mathematical Tables, 9th printing. In this example, the 1.72 cm/s is rounded to 1.7 cm/s. Joint Committee for Guides in Metrology (2011). http://parasys.net/error-propagation/error-propagation-analysis-for-file-systems.php However, if the variables are correlated rather than independent, the cross term may not cancel out.

Engineering and Instrumentation, Vol. 70C, No.4, pp. 263-273. Error Propagation Division What is the uncertainty of the measurement of the volume of blood pass through the artery? ISSN0022-4316.

## Practically speaking, covariance terms should be included in the computation only if they have been estimated from sufficient data.

For example, if you have a measurement that looks like this: m = 20.4 kg ±0.2 kg Thenq = 20.4 kg and δm = 0.2 kg First Step: Make sure that General function of multivariables For a function q which depends on variables x, y, and z, the uncertainty can be found by the square root of the squared sums of the Generally, reported values of test items from calibration designs have non-zero covariances that must be taken into account if b is a summation such as the mass of two weights, or Error Propagation Physics October 9, 2009.

Accounting for significant figures, the final answer would be: ε = 0.013 ± 0.001 L moles-1 cm-1 Example 2 If you are given an equation that relates two different variables and We will state the general answer for R as a general function of one or more variables below, but will first cover the specail case that R is a polynomial function This is desired, because it creates a statistical relationship between the variable $$x$$, and the other variables $$a$$, $$b$$, $$c$$, etc... click site ProfessorSerna 7,172 views 7:27 Simple Calculations of Average and the Uncertainty in the Average - Duration: 4:22.

Please try the request again. Advisors For Incoming Students Undergraduate Programs Pre-Engineering Program Dual-Degree Programs REU Program Scholarships and Awards Student Resources Departmental Honors Honors College Contact Mail Address:Department of Physics and AstronomyASU Box 32106Boone, NC Plugging this value in for ∆r/r we get: (∆V/V) = 2 (0.05) = 0.1 = 10% The uncertainty of the volume is 10% This method can be used in chemistry as f k = ∑ i n A k i x i  or  f = A x {\displaystyle f_ ρ 5=\sum _ ρ 4^ ρ 3A_ ρ 2x_ ρ 1{\text{ or }}\mathrm

SOLUTION Since Beer's Law deals with multiplication/division, we'll use Equation 11: $\dfrac{\sigma_{\epsilon}}{\epsilon}={\sqrt{\left(\dfrac{0.000008}{0.172807}\right)^2+\left(\dfrac{0.1}{1.0}\right)^2+\left(\dfrac{0.3}{13.7}\right)^2}}$ $\dfrac{\sigma_{\epsilon}}{\epsilon}=0.10237$ As stated in the note above, Equation 11 yields a relative standard deviation, or a percentage of the For example, repeated multiplication, assuming no correlation gives, f = A B C ; ( σ f f ) 2 ≈ ( σ A A ) 2 + ( σ B This example will be continued below, after the derivation (see Example Calculation). Practice online or make a printable study sheet.

In both cases, the variance is a simple function of the mean.[9] Therefore, the variance has to be considered in a principal value sense if p − μ {\displaystyle p-\mu } About Press Copyright Creators Advertise Developers +YouTube Terms Privacy Policy & Safety Send feedback Try something new! is formed in two steps: i) by squaring Equation 3, and ii) taking the total sum from $$i = 1$$ to $$i = N$$, where $$N$$ is the total number of Guidance on when this is acceptable practice is given below: If the measurements of a and b are independent, the associated covariance term is zero.

In fact, since uncertainty calculations are based on statistics, there are as many different ways to determine uncertainties as there are statistical methods. References Skoog, D., Holler, J., Crouch, S. Therefore, the ability to properly combine uncertainties from different measurements is crucial. Jason Harlow 8,916 views 17:08 Error Propagation - Duration: 7:27.

National Bureau of Standards. 70C (4): 262. Khan Academy 497,237 views 15:15 IB Physics- Uncertainty and Error Propagation - Duration: 7:05. Since uncertainties are used to indicate ranges in your final answer, when in doubt round up and use only one significant figure.


text:
fitbenchmarking.cost_func.nlls_cost_func module

Implements the non-weighted non-linear least squares cost function

class fitbenchmarking.cost_func.nlls_cost_func.NLLSCostFunc(problem)

This defines the non-linear least squares cost function where, given a set of $$n$$ data points $$(x_i,y_i)$$, associated errors $$e_i$$, and a model function $$f(x,p)$$, we find the optimal parameters in the root least-squares sense by solving:

$\min_p \sum_{i=1}^n \left(y_i - f(x_i, p)\right)^2$

where $$p$$ is a vector of length $$m$$, and we start from a given initial guess for the optimal parameters. More information on non-linear least squares cost functions can be found here.

eval_r(params, **kwargs)

Calculate the residuals, $$y_i - f(x_i, p)$$

Parameters

params (list) – The parameters, $$p$$, to calculate residuals for

Returns

The residuals for the datapoints at the given parameters

Return type

numpy array

hes_res(params, **kwargs)

Uses the Hessian of the model to evaluate the Hessian of the cost function residual, $$\nabla_p^2 r(x,y,p)$$, at the given parameters.

Parameters

params (list) – The parameters at which to calculate Hessians

Returns

evaluated Hessian and Jacobian of the residual at

each x, y pair :rtype: tuple(list of 2D numpy arrays, list of 1D numpy arrays)

jac_res(params, **kwargs)

Uses the Jacobian of the model to evaluate the Jacobian of the cost function residual, $$\nabla_p r(x,y,p)$$, at the given parameters.

Parameters

params (list) – The parameters at which to calculate Jacobians

Returns

evaluated Jacobian of the residual at each x, y pair

Return type

a list of 1D numpy arrays


text:
# Nondeterministic finite state complexity

Graduate student Kayleigh Hyde will present her Master’s project on Monday April 22, 10:30am, in Shidler College of Business Room E201. Draft paper

Let $M$ be a nondeterministic finite automaton, having $q$ states and no $\epsilon$-transitions. If there is exactly one path through $M$ of length $n$ leading to an accept state, and $x$ is the string read along that path, then we say that $A_N(x)\le q$ (the NFS complexity of $x$ is at most $q$).


text:
How to determine the no arbitrage price of following claim? (change of numeraire)

How do I determine the no arbitrage price for claims such as $$min(S_1(T),S_2(T))$$ or $$max(S_1(T),S_2(T))$$? We can consider a standard Black Scholes model. Hence $$S_i(T)=S_i(t)e^{(r-\sigma_i^2/2)(T-t)+\sigma_i(W(T)-W(t))}$$ and that W is brownian motion.

After some reading I saw that I need to perform change of numeraire when valuating the NA price for these kind of claims. Could anyone guide me? Thank you.

\begin{align} &\max(S_T^1,S_T^2)=S_T^2+\max(S_T^1-S_T^2,0) \\ &\min(S_T^1,S_T^2)=S_T^2-\max(S_T^2-S_T^1,0) \end{align} Terms of the form $$\max(S_T^i-S_T^j,0)$$ can be evaluated with the Margrabe’s formula in a Black-Scholes framework.
Regarding the change of numéraire, I give a sketch of how one would proceed. Letting $$\xi_T$$ be the payoff at $$T$$, we have in all generality, with $$B_T$$ the money market account: \begin{align} E^\mathcal{Q}\left(\frac{\xi_T}{B_T}\right)&=E^\mathcal{S}\left(\frac{B_TS_0}{B_0S_T}\frac{\xi_T}{B_T}\right) \\ &=S_0E^\mathcal{S}\left(\frac{\xi_T}{S_T}\right) \end{align} where $$\mathcal{Q}$$ is the risk-neutral measure, with the money market account as numéraire, and $$\mathcal{S}$$ the measure with the stock price as numéraire (note that $$B_0=1$$). Here, $$\xi_T=\max(S_T^i-S_T^j,0)$$ hence if you choose $$S^j$$ as numéraire you get: $$E^\mathcal{Q}\left(\frac{\xi_T}{B_T}\right)=S_0^jE^{\mathcal{S}^j}\left(\max\left(\frac{S_T^i}{S_T^j}-1,0\right)\right)$$ The ratio $$S^i/S^j$$ will be lognormally distributed in a Black-Scholes framework. Keep in mind you need to ensure the ratio is martingale, as any traded asset rebased by a numéraire is a martingale under the measure associated to that numéraire. For that, you have to apply Itô’s Lemma to the ratio and define the Brownian Motion $$W^{\mathcal{S}^j}_t=W^\mathcal{Q}_t+\theta_t$$ by setting $$\theta_t$$ such that $$S^i/S^j$$ has no drift.


text:
# [texhax] bad printout of large brackets

Lars Madsen daleif at imf.au.dk
Mon Dec 28 20:53:31 CET 2009

I.J.L. Garces wrote:
> Hello, everybody!
>
> I have a problem on my latex printout.
>
> I am using WinEdt to typeset my LaTeX file. I have two examples below.
>
> $f(x)=\left\{ > \begin{array}{lcl} > \dfrac{2}{2-x} & & \mbox{if 0 \le x < 2} \\ > \\ > 0 & & \mbox{if x \ge 2,} > \end{array} > \right.$
>
> $\left\{ > \begin{array}{lcl} > 2x & \equiv & 11 \pmod{13} \\ > 3x & \equiv & 7 \pmod{9} \\ > 7x & \equiv & 5 \pmod{8} > \end{array} > \right.$
>
> After I compile it using pdflatex, in the paper printout, the big
> bracket turns out not a solid curly bracket, but a broken one. There are
> some breaks near the middle of the curl in the printout. Only on the
> printed copy on the paper, but the pdf copy I see onscreen is perfect.
> use pdflatex compilation because I have figures in pdf format.
>
> Can you please help me again?
>
> Thank you very much... and happy new year to everyone!
>
> Best regards,
> Ian June
>

it might help with a full minimal example and some information about
your LaTeX distribution (the editor has nogthing to do with it)

/daleif

More information about the texhax mailing list


text:
# Staff Change Line

5 messages
Open this post in threaded view
|

## Staff Change Line

 Hello! I'm kinda new to Lilypond but I know it's an incredible tool. Unfortunately, I am currently facing a problem that I don't know what to do anymore. I'm trying to replicate an (actually easy) piece used in our church as a practice to be more familiarized with common Lilypond things that are usually done in making a sheet music but I'm stuck to what to do in this part. I've tried searching previous posts in the nabble forum (which I think is a mirror of the ones getting sent to the mailing list?) for similar problems but I can't find one, so I decided to ask about it. This is the part that I am trying to replicate. Here it is in Lilypond code without the "staff change line" or whatever that line was actually called (just the notes): So now, I'm stuck. I don't really know what to do because the part has polyphonic voices. Also, the example in Lilypond doc about Staff Change Lines has the music perfectly fit the time signature. Whereas here, the line points to the second voice in the measure and (if I do something like what was on the docs), it will be over the count of beats, which didn't work (I think) when I tried it. I tried some other things too, but none worked. I believe this would need some "hacks" or some advanced thing that I don't know and I haven't seen yet in the documentation. Thanks for the help! -- Sent from: http://lilypond.1069038.n5.nabble.com/User-f3.html_______________________________________________ lilypond-user mailing list [hidden email] https://lists.gnu.org/mailman/listinfo/lilypond-user
Open this post in threaded view
|

## Re: Staff Change Line

 Forgive me for sending multiple messages but the code snippet in my previous message didn't make it in the email. Sorry, I used the raw tag in the nabble forum and it was stripped in the email sent to the mailing list. Sorry for not knowing that will happen. By the way, here is the code of that measure: \version "2.18.2" \new PianoStaff <<   \new Staff {     \time 4/4     \clef "treble"     \relative c' {       \key g \major       << { e2~ e8 d d4 } \\ { 4. c8 c4 4 } >> |     }   }   \new Staff {     \time 4/4     \clef "bass"     \relative c, {       \key g \major       << { r8 e'8 e2 } \\ { g,2. \stemUp 4 } >> \stemNeutral |     }   } >> Thank you, and again, forgive my ignorance regarding my code being stripped in the email. -- Sent from: http://lilypond.1069038.n5.nabble.com/User-f3.html_______________________________________________ lilypond-user mailing list [hidden email] https://lists.gnu.org/mailman/listinfo/lilypond-user
Open this post in threaded view
|

## Re: Staff Change Line

 Am 31.03.19 um 14:43 schrieb Erwinstein: > Forgive me for sending multiple messages but the code snippet in my previous > message didn't make it in the email. Sorry, I used the raw tag in the nabble > forum and it was stripped in the email sent to the mailing list. Sorry for > not knowing that will happen. > > By the way, here is the code of that measure: > > \version "2.18.2" > > \new PianoStaff << >    \new Staff { >      \time 4/4 >      \clef "treble" >      \relative c' { >        \key g \major >        << { e2~ e8 d d4 } \\ { 4. c8 c4 4 } >> | >      } >    } >    \new Staff { >      \time 4/4 >      \clef "bass" >      \relative c, { >        \key g \major >        << { r8 e'8 e2 } \\ { g,2. \stemUp 4 } >> \stemNeutral | >      } >    } (There's a >> missing.) One simple solution would be: \version "2.18.2" \new PianoStaff <<    \new Staff = "upper" {      \time 4/4      \clef "treble"      \relative c' {        \key g \major        << { e2~ e8 d d4 } \\ { 4. s8 s4 4 } >> |      }    }    \new Staff {      \time 4/4      \clef "bass"      \relative c, {        \key g \major        << { r8 e'8 e2*1/4\glissando \change Staff = "upper" \voiceTwo c'8 c4 } \\ { g,2. \oneVoice 4 } >> |      }    }  >> Note that I removed your usage of \stemXXX commands; their use is generally discouraged since there's more difference between upper and lower voices in a staff than just the stem direction. It's almost always better to use \voiceOne, \voiceTwo etc. and \oneVoice (except for situations where you really want to influene the stem direction _only_). Best Lukas _______________________________________________ lilypond-user mailing list [hidden email] https://lists.gnu.org/mailman/listinfo/lilypond-user


text:
# Lovable Linux

Entire Assignment due 2020-05-06 23:59
• kernel.c

## Learning Objectives #

The learning objectives for Lovable Linux are:

• Building Character
• Proving a Point

## ECE 391 vs. CS 241 #

A common point of contention among ECE and CS majors: “Is CS 241 harder than ECE 391?”. This has probably been debated, since the beginning of either course’s conception. Your TAs discussed this and wanted to settle this question once and for all. ECE 391 is known for their killer semester long final project, which is building an operating system from scratch. Normally a 391 student is given 6 weeks and 3 partners to finish this assignment, but since 241 students are superior programmers we feel that 1.5 weeks should be plenty of time to do this on your own. We decided that, since this assignment is very demanding we would make it worth 50% of your lab assignment grade in the class meaning that you can NOT use your 1 lab drop on this. The rest of the documentation and starter code is transcribed from the actual assignment.

## Introduction #

Read the Whole document before you begin, or you may miss points on some requirements (for example, the bug log).

In this machine problem, you will work in teams to develop the core of an operating system. We will provide you with code that boots you into protected mode, sets up the GDT, LDT, and initial TSS, and maps a read-only file system image into physical memory for you. You must set up the interrupt descriptor table (IDT), basic paging support for tasks, separate 4 MB pages for the kernel and applications, initialize a few devices, write the system call interface along with ten system calls, provide support for six tasks from program images in the file system which interface with the kernel via system calls, multiple terminals and basic scheduling.

The goal for the assignment is to provide you with hands-on experience in developing the software used to interface between devices and applications, i.e., operating systems. We have deliberately simplified many of the interfaces to reduce the level of effort necessary to complete the project, but we hope that you will leave the class with the skills necessary to extend the implementation that you develop here along whatever direction you choose by incrementally improving various aspects of your system.

## Processor Initialization #

You learned about the global descriptor table (GDT) in class. Linux creates four segments in this table: Kernel Code Segment, Kernel Data Segment, User Code Segment, and User Data Segment. In x86_desc.S, starting at line 38, we have created an empty GDT for you.

Write code that makes an emulated Intel IA-32 processor use this GDT. We have marked a location in the code (boot . 8 line 27) at which you will need to place this initialization code for the GDT to ensure that you follow the correct boot sequence. You will need to look through the ISA Reference Manual for information about how to write this code (https://courses.engr.illinois.edu/ece391/secure/references/IA32-ref-manual-vol-3.pdf)

### Initialize the IDT

Your IDT must contain entries for exceptions, a few interrupts, and system calls. Consult the x86 ISA manuals for the descriptor formats and please see Appendix D for more information. The exception handler(s) should use the printing support to report errors when an exception occurs in the kernel, and should squash any user-level program that produces an exception, returning control to the shell (the shell should not cause an exception in a working OS)- see System Calls (Appendix B) for further details. You will also need to handle interrupts for the keyboard and the RTC. Finally, you will need to use entry ox8 0 for system calls, as described below.

### Initialize the Devices

Adapt the initialization code from Linux to initialize the PIC, the keyboard, and the RT C. Set up a general-purpose infrastructure similar to what is done in the Linux kernel. You need to handle the keyboard and RT C interrupts, but you also need to make sure that these devices are initialized before taking interrupts. We suggest that you first mask out all interrupts on the PIC, then initialize the PIC, initialize the devices, and, as part of each device’s initialization, enable its associated interrupt on the PIC. The handler addresses should be installed dynamically/indirectly via a data structure used by the default handlers (as in Linux). You may also want to review the RT C data sheet linked from the class web page.

For the checkpoint, your OS must execute the test_interrupts handler (provided in lib.c) when an RTC interrupt occurs. When a keyboard interrupt occurs, you must echo the correct characters to the screen. These simple tests will determine if you have the IDT entries set up correctly, the PIC enabled, and the devices initialized and able to generate interrupts.

### Initialize Paging

As preparation for the next steps in the MP you must have paging enabled and working. You will be creating a page directory and a page table with valid page directory entries (PDEs) and page table entries (PTEs). More information about this process appears in Appendix C and in the Intel ISA manual linked from the class web page.

The image to the right shows how virtual and physical memory are laid out for this checkpoint. To keep things simple, the kernel and video memory will be at the same location in virtual memory as they are in physical memory. Your kernel code is already loaded at 4 MB for you, so you need only map virtual memory 4-8 MB to physical memory at 4-8 MB. This kernel page should be a single 4 MB page, whereas the first 4 MB of 4 MB memory should broken down into 4 kB pages. In addition to 8MB to 4GB being marked not present, you should also set any unused pages to not present as well. In this layout everything in Kernel the first 4MB, that isn’t the page for video memory, should be marked not present.

Make sure that you align your pages (page directory and page 8 MB tables) on 4 kB boundaries. To align things in x86:

.align BYTES_TO_ALIGN_TO
label:
(whatever you want aligned)

To align things in C:

int some_variable _attribute_((aligned (BYTES_TO_ALIGN_TO)

### Handin

For this handin, we expect you to have written your own “blue screen” of death for each of the exceptions. At a minimum, this screen must identify the exception taken. You may also want to read about how exceptions are handled in the Intel ISA and print more useful information, such as the memory address reference that caused a page fault. This information will be of use to you later for debugging. We expect you to be able to boot your operating system with paging turned on and to enter a halt loop or a while (1) loop. Then we expect you to boot your operating system and explicitly dereference NULL to demonstrate your “blue screen” identifying the resulting page fault. We also expect you to be able to press a key and demonstrate that your operating system reaches the test_interrupts function in on RTC interrupts, but you do not need to write a full interrupt handler for RTC yet, merely show that you can receive interrupts. Finally, we expect your keyboard interrupt handler to echo the correct character to the screen, although where each character appears on the screen doesn’t matter. As with the RTC, you need not write a full interrupt handler for the keyboard for this checkpoint.

## Device Drivers #

### Create a Terminal Driver

When any printable characters are typed at the keyboard, they should be displayed to the screen. This includes handling all alphanumeric characters, symbols, shift and capslock, but you do not need to support the number pad. You will now need to keep track of the screen location for this purpose. You do need to support vertical scrolling (but not history) and will need to interpret CTRL-L (non-printable key) as meaning “clear the screen and put the cursor at the top” which will make your testing experience more pleasant. You do also need to support backspace and line-buffered input. The size of the buffer should be 128 characters for this checkpoint. For more details on how the terminal read and write functions should work, and how to handle the buffer filling up, please see Appendix B.

Keep in mind that you will also want to have an external interface to support delivery of external data to the terminal output. In particular, write system calls to the terminal should integrate cleanly with keyboard input. The hello program in the file system will eventually help to test the basics, but for now its source code will show you how user programs will pass parameters to your terminal.

### Parse the Read-only File System

You will need to support operations on the file system image provided to you, including opening and reading from files, opening and reading the directory (there’s only one-the structure is flat), and copying program images into contiguous physical memory from the randomly ordered 4 kB “disk” blocks that constitute their images in the file system. The source code for our 15 program will show you how reading directories is expected to work. Also see Appendix A for an overview of the file system as well as Appendix B for how each function should work.

### The Real-Time Clock Driver

You will need to write the open, read, write, and close functions for the real-time clock (RTC) and demonstrate that you can change the clock frequency. You will need to do some research on how the RTC works and what the device driver needs to do to communicate with it. Virtualizing the RT C is not required, but does make testing easier when you run multiple programs with the RT C open. Again, see Appendix B for how each function should work.

### Handin

For this handin, you will need to demonstrate that your open, read, and write functions for the three device drivers work correctly. This functionality is independent of how your operating system may use the devices, but it is a good idea for you to start thinking about how you want to interface these functions with the corresponding system calls (see Appendix B).

You will need to show that when a key is pressed, the keyboard driver stores the corresponding letter in a buffer and that by explicitly calling the keyboard read function you can receive the correct letters and print them out on the screen. Similarly, you will need to demonstrate that you can change the rate of the RT C clock using the write function and that the read function returns after an interrupt has occurred. A good way of doing so is by having the RT C interrupt handler increment a counter and write to a specific spot on the screen.

Finally, you will need to demonstrate that you can read from the read-only file system. A good check for this test is to use the xxd command, which prints a hexadecimal dump, to compare the output of your file system code with the bytes stored in the file system image. Please note that you should run xxd on filesys_img and not the individual executables; as your code reads from the filesystem image, its output might not directly match that of xxd run on the individual executables. For the handin, you must have some test/wrapper code that given a filename, a buffer, and a buffer length, will read data from the given file into the buffer.

## System Calls and Tasks #

### Support System Calls

Eventually, all ten system calls must be supported via a common IDT entry, so you will have to set up some generic assembly linkage along the lines of that used in Linux, including syscall value checking, register save and restore, and a jump table to C functions that implement the system calls themselves. The details of each call are provided in Appendix B.

For this checkpoint, you only need to support the system calls necessary to run testprint from shell: execute, halt, and open/close/read/write for the terminal and filesystem.

Programs execute to completion, so you need not write a scheduler or deal with the timer chip yet, but you do need to be able to squash programs if they generate exceptions, returning control to the shell in such cases.

As in Linux, the tasks will share common mappings for kernel pages, in this case a single, global 4 MB page. Unlike Linux, we will provide you with set physical addresses for the images of the two tasks, and will stipulate that they require no more than 4 MB each, so you need only allocate a single page for each task’s user-level memory. See Appendix C for more details.

Extend the code for your file system driver to copy a program image from the randomly ordered 4 kB “disk” blocks constituting the image in the file system into contiguous physical memory.

This process is normally performed by a program loader in cooperation with the OS, but in your case will be performed completely within the kernel, since the file system code and control of the memory is internal.

In addition, you will need to set up the stack properly and then return into user-level, since privilege level 0 cannot call down into privilege level 3, and your user-level code must execute at the lower privilege level.

### Executing User-level Code

Kernel code executes at privilege level 0, while user-level code must execute at privilege level 3. The x86 processor does not allow a simple function call from privilege level 0 code to privilege level 3, so you must use an x86-specific convention to accomplish this privilege switch.

The convention to use is the IRET instruction. Read the ISA reference manual for the details of this instruction. You must set up the correct values for the user-level EIP, CS, EFLAGS, ESP, and SS registers on the kernel-mode stack, and then execute an IRET instruction. The processor will pop the values off the stack into those registers, and by doing this, will perform a privilege switch into the privilege level specified by the low 2 bites of the CS register. The values for the CS and SS registers must point to the correct entries in the Global Descriptor Table that correspond to the user-mode code and stack segments, respectively. The EIP you need to jump to is the entry point from bytes 24-27 of the executable that you have just loaded. Finally, you need to set up a user-level stack for the process. For simplicity, you may simply set the stack pointer to the bottom of the 4 MB page already holding the executable image. Two final bits: the DS register must be set to point to the correct entry in the GDT for the user mode data segment (USER_DS) before you execute the IRET instruction (conversely, when an entry into the kernel happens, for example, through a system call, exception, or interrupt, you should set D8 to point to the KERNEL_DS segment). Finally, you will need to modify the TSS; this is explained in Appendix E.

## Completing System Calls and Tasks #

For this handin, we expect that you have all of the system calls working and that all of the programs we have provided to you will execute without problems. You are also expected to handle the multiple “shell” case where you execute a shell from the first shell. Just for this checkpoint, you can assume a maximum of two programs. Further programs should not be allowed to run. You can exit shells by typing “exit”, and return to the previous shell. You will also be expected to be able to answer questions about how you got various system calls to work and about the task structures that you created.

## Scheduling #

For the final due date, the following functionality must be implemented:

### Multiple Terminals and Active Tasks

As you may already know, it is possible to switch between different terminals in Linux using the ALT+Function-Key combination. You will need to add a similar feature by running several instances of the shell executable. You must support three terminals, each associated with a different instance of shell. As an example, pressing ALT+F2 while in the first terminal must switch to the active task of the second terminal. Further, you must support up to six processes in total. For example, each terminal running shell running another program. For the other extreme, have 2 terminals running 1 shell and have 1 terminal running 4 programs (a program on top of shell, on top of shell, etc). In order to support the notion of a terminal, you must have a separate input buffer associated with each terminal. In addition, each terminal should save the current text screen and cursor position in order to be able to return to the correct state. Switching between terminals is equivalent to switching between the associated active tasks of the terminals. Finally, your keyboard driver must intercept ALT+Function-Key combinations and perform terminal switches. Lastly, keep in mind that even though a process can be interrupted in either user mode or in kernel mode (while waiting in a system call). After the interrupt, the processor will be in kernel mode, but the data saved onto the stack depends on the state before the interrupt. Each process should have its own kernel stack, but be careful not to implicitly assume either type of transition.

### Handin

For this final handin, we expect you to demonstrate that multiple terminals work by switching between active terminals. We will execute a program on one screen, switch to another screen, start another program, and then expect to be able to switch back and forth to see the programs running. For scheduling, we expect that programs running in the background (on an inactive terminal) will make progress. For example, we expect a fish program running on such a terminal to continue despite not actually being displayed on the screen.

## Bells and Whistle #

The following is OPTIONAL and is only for fun:

### Signals

Add support for delivery of five different signals to a task. Appendix F details the specifications and implementation details to make this work.

### Dynamic Memory Allocation

Create a dynamic memory allocator (such as malloc). This can be done by simply keeping track of where free pages are using some method, then creating a malloc system call that adds a new page to the program’s page table or page directory. Remember that implementing dynamic memory will not get you any extra credit if you don’t have a way of demoing the functionality. For example, writing a short user program or some kind of kernel-level functionality.

### Other Ideas

Go wild, find something interesting to add to your operating system and explain it. We will consider the difficulty of any addition when determining whether and how much extra credit is merited. For example, don’t expect a huge grade increase for adding color support for text.

## Appendix A: The File System #

### File System Utilities

The figure below shows the structure and contents of the file system. The file system memory is divided into 4 kB blocks. The first block is called the boot block, and holds both file system statistics and the directory entries. Both the statistics and each directory entry occupy 64B, so the file system can hold up to 63 files. The first directory entry always refers to the directory itself, and is named “.”, so it can really hold only 62 files.

Each directory entry gives a name (up to 32 characters, zero-padded, but not necessarily including a terminal EOS or O-byte), a file type, and an index node number for the file. File types are 0 for a file giving user-level access to the real-time clock (RTC), 1 for the directory, and 2 for a regular file. The index node number is only meaningful for regular files and should be ignored for the RTC and directory types. Each regular file is described by an index node that specifies the file’s size in bytes and the data blocks that make up the file. Each block contains 4 kB; only those blocks necessary to contain the specified size need be valid, so be careful not to read and make use of block numbers that lie beyond those necessary to contain the file data.

int32_t read_dentry_by_name (const uint8_t* fname, dentry_t* dentry);
int32_t read_dentry_by_index (uint32_t index, dentry-t* dentry);
int32_t read_data (uint32_t inode, uint32_t offset, uint8_t* buf, uint32_t length);

The three routines provided by the file system module return -1 on failure, indicating a non-existent file or invalid index in the case of the first two calls, or an invalid inode number in the case of the last routine. Note that the directory entries are indexed starting with 0. Also note that the read_data call can only check that the given inode is within the valid range. It does not check that the inode actually corresponds to a file (not all inodes are used). However, if a bad data block number is found within the file bounds of the given inode, the function should also return -1. When successful, the first two calls fill in the dentry_t block passed as their second argument with the file name, file type, and inode number for the file, then return 0. The last routine works much like the read system call, reading up to length bytes starting from position off set in the file with inode number inode and returning the number of bytes read and placed in the buffer. A return value of 0 thus indicates that the end of the file has been reached.

### File System Abstractions

Each task can have up to 8 open files. These open files are represented with a file array, stored in the process control block (PCB). The integer index into this array is called a file descriptor, and this integer is how user-level programs identify the open file.

This array should store a structure containing:

1. The file operations jump table associated with the correct file type. This jump table should contain entries for open, read, write, and close to perform type specific actions for each operation. open is used for performing type specific initialization. For example, if we just open’d the RTC, the jump table pointer in this structure should store the RTC’s file operations table.

2. The inode number for this file. This is only valid for data files, and should be 0 for directories and the RTC device file.

3. A “file position” member that keeps track of where the user is currently reading from in the file. Every read system call should update this member.

4. A “flags” member for, among other things, marking this file descriptor as “in-use.”

When a process is started, the kernel should automatically open stdin and stdout, which correspond to file descriptors O and 1, respectively. stdin is a read-only file which corresponds to keyboard input. stdout is a write-only file corresponding to terminal output. “Opening” these files consists of storing appropriate jump tables in these two locations in the file array, and marking the files as in-use. For the remaining six file descriptors available, an entry in the file array is dynamically associated with the file being open‘d whenever the open system call is made (return -1 if the array is full).

## Appendix B: The System Calls #

You must support ten system calls, numbered 1 through 10. As with Linux, they are invoked using int 0x80, and use a similar calling convention. In particular, the call number is placed in EAX, the first argument in EBX, then ECX, and finally EDX. No call uses more than three arguments, although you should protect all of the registers from modification by the system call to avoid leaking information to the user programs. The return value is placed in EAX if the call returns (not all do); a value of -1 indicates an error, while others indicate some form of success. Prototypes appear below. Unless otherwise specified, successful calls should return 0, and failed calls should return - 1.

1. int32_t halt (uint8_t status);
2. int32_t execute (const uint8_t* command);
3. int32_t read (int32_t fd, void* buf, int32_t nbytes);
4. int32_t write (int32_t fd, const void* buf, int32_t nbytes);
5. int32_t open (const uint8-t* filename);
6. int32_t close (int32_t fd);
7. int32_t getargs (uint8_t* buf, int32_t nbytes);
8. int32_t vidmap (uint8_t** screen_start);
9. int32_t set_handler (int32_t signum, void* handler_address);
10. int32_t sigreturn (void);

The execute system call attempts to load and execute a new program, handing off the processor to the new program until it terminates. The command is a space separated sequence of words. The first word is the file name of the program to be executed, and the rest of the command stripped of leading spaces should be provided to the new program on request via the getargs system call. The execute call returns -1 if the command cannot be executed, for example, if the program does not exist or the filename specified is not an executable, 256 if the program dies by an exception, or a value in the range 0 to 255 if the program executes a halt system call, in which case the value returned is that given by the program’s call to halt.

The halt system call terminates a process, returning the specified value to its parent process. The system call handler itself is responsible for expanding the 8-bit argument from BL into the 32-bit return value to the parent program’s execute system call. Be careful not to return all 32 bits from EBX. This call should never return to the caller.

The read system call reads data from the keyboard, a file, device (RTC), or directory. This call returns the number of bytes read. If the initial file position is at or beyond the end of file, 0 shall be returned (for normal files and the directory). In the case of the keyboard, read should return data from one line that has been terminated by pressing Enter, or as much as fits in the buffer from one such line. The line returned should include the line feed character. In the case of a file, data should be read to the end of the file or the end of the buffer provided, whichever occurs sooner. In the case of reads to the directory, only the filename should be provided (as much as fits, or all 32 bytes), and subsequent reads should read from successive directory entries until the last is reached, at which point read should repeatedly return 0. For the real time clock (RTC), this call should always return 0, but only after an interrupt has occurred (set a flag and wait until the interrupt handler clears it, then return 0). You should use a jump table referenced by the task’s file array to call from a generic handler for this call into a file type specific function. This jump table should be inserted into the file array on the open system call (see below).

The write system call writes data to the terminal or to a device (RTC). In the case of the terminal, all data should be displayed to the screen immediately. In the case of the RTC, the system call should always accept only a 4-byte integer specifying the interrupt rate in Hz, and should set the rate of periodic interrupts accordingly. Writes to regular files should always return -1 to indicate failure since the file system is read only. The call returns the number of bytes written, or -1 on failure.

The RTC device itself can only generate interrupts at a rate that is a power of 2 (do a parameter check), and only up to 8192 Hz. Your kernel should limit this further to 1024 Hz - an operating system shouldn’t allow userspace programs to generate more than 1024 interrupts per second by default. Look at drivers/char/rtc.c, include/linux/mc146818rtc.h and possibly other associated header files for the macros and port numbers for interfacing with the RTC device. Note that you should be using the RTC’s Periodic Interrupt function to generate interrupts at a programmable rate. The RTC interrupt rate should be set to a default value of 2 Hz (2 interrupts per second) when the RTC device is opened. For simplicity, RTC interrupts should remain on at all times.

The open system call provides access to the file system. The call should find the directory entry corresponding to the named file, allocate an unused file descriptor, and set up any data necessary to handle the given type of file (directory, RT C device, or regular file). If the named file does not exist or no descriptors are free, the call returns -1.

The close system call closes the specified file descriptor and makes it available for return from later calls to open. You should not allow the user to close the default descriptors (O for input and l for output). Trying to close an invalid descriptor should result in a return value of -l; successful closes should return 0.

The getargs call reads the program’s command line arguments into a user-level buffer. Obviously, these arguments must be stored as part of the task data when a new program is loaded. Here they are merely copied into user space. If the arguments and a terminal NULL (O-byte) do not fit in the buffer, simply return -1. The shell does not request arguments, but you should probably still initialize the shell task’s argument data to the empty string.

The vidmap call maps the text-mode video memory into user space at a preset virtual address. Although the address returned is always the same (see the memory map section later in this handout), it should be written into the memory location provided by the caller (which must be checked for validity). If the location is invalid, the call should return -1. To avoid adding kernel side exception handling for this sort of check, you can simply check whether the address falls within the address range covered by the single userlevel page. Note that the video memory will require you to add another page mapping for the program, in this case a 4 kB page. It is not ok to simply change the permissions of the video page located < 4MB and pass that address.

The set_handler and sigreturn calls are related to signal handling and are discussed in the section Signals below. Even if your operating system does not support signals, you must support these system calls; in such a case, however, you may immediately return failure from these calls.

Note that some system calls need to synchronize with interrupt handlers. For example, the read system call made on the RTC device should wait until the next RTC interrupt has occurred before it returns. Use simple volatile flag variables to do this synchronization (e.g., something like int rtc_interrupt_occurred;) when possible (try some thing more complicated only after everything works!), and small critical sections with cli/sti. For example, writing to the RT C should block interrupts to interact with the device. Writing to the terminal also probably needs to block interrupts, if only briefly, to update screen data when printing (keyboard input is also printed to the screen from the interrupt handler).

## Appendix C: Memory Map and Task Specification #

When processing the execute system call, your kernel must create a virtual address space for the new process. This will involve setting up a new Page Directory with entries corresponding to the figure shown on the right. The virtual memory map for each task is show in the figure. The kernel is loaded at physical address 0x400000 (4 MB), 128MB and also mapped at virtual address 4 MB. A global page directory entry with its Supervisor bit set should be set up to map the kernel to virtual address ox400000 (4 MB). This ensures that the kernel, which is linked to run with its starting address at 4 MB, will continue to work even after paging is turned on.

To make physical memory management easy, you may assume there is at least 16 MB of physical memory on the system. Then, use the following (static) strategy: the first user-level program (the shell) should be loaded at physical 8 MB, and the second user-level program, when it is executed by the shell, should be loaded at physical 12 MB. The program image itself is linked to execute at virtual address 0x08048000. The way to get this working is to set up a single 4 MB page directory entry that maps virtual address 0x08000000 (128 MB) to the right physical memory address (either 8 MB or 12 MB). Then, the program image must be copied to the correct offset (0x00048000) within that page.

Both the kernel mapping and the user-level program mapping are critical; memory references in neither the kernel nor the program will not work correctly unless they are mapped at these exact addresses.

The layout of executable files in the file system is simple: the entire file stored in the file system is the image of the program to be executed. In this file, a header that occupies the first 40 bytes gives information for loading and starting the program. The first 4 bytes of the file represent a “magic number” that identifies the file as an executable. These bytes are, respectively, 0: 0x7f; 1: 0x45; 2: 0x4c; 3: 0x46. If the magic number is not present, the execute system call should fail. The other important bit of information that you need to execute programs is the entry point into the program, i.e., the virtual address of the first instruction that should be executed. This information is stored as a 4-byte unsigned integer in bytes 24-27 of the executable, and the value of it falls somewhere near 0x08048000 for all programs we have provided to you. When processing the execute system call, your code should make a note of the entry point, and then copy the entire file to memory starting at virtual address 0x08048000. It then must jump to the entry point of the program to begin execution. The details of how to jump to this entry point are explained in the next section.

## Appendix D: System Calls, Exceptions, and Interrupts #

Recall that when a hardware interrupt is asserted or a hardware exception is detected, a specific number is associated with the exception or interrupt to differentiate between different types of exceptions, or different hardware devices (for example, differentiating between the keyboard interrupt, the network card interrupt, and a divide-by-zero exception). This number is used to index a table, called the Interrupt Descriptor Table, or IDT. The format of an IDT entry is shown in the figure below, and the details of it are found in the Intel architecture manuals (see the “Getting Started” section for more info on references). Each IDT entry contains, among other things, a pointer to the corresponding interrupt handler function to be run when that interrupt is received. When an exception or hardware interrupt is detected, the processor switches into privilege level 0 (kernel mode), saves some, but not all of the processor registers on the kernel stack (see Appendix E for more details), and jumps to the function address specified in the entry. Now, kernel code, specifically the interrupt handler for the correct interrupt number, is now executing.

For system calls, you will use a similar mechanism. A user-level program will execute a int $0x80 instruction. The int instruction functions similar to an exception. It specifies that the processor should use entry 0x80 in the IDT as the handler when this instruction is executed. The same privilege-level switching, stack switching, etc, are all performed, so after this instruction is run, kernel code will be executing. You must set up a “system call handler” IDT entry at index ox80, as well as a function that will be run for all system calls. This function can then differentiate different system calls based on the parameter passed in EAX. For this to work properly, you must pay attention to a few details of the x86 architecture and protection scheme when setting up the IDT. The IDT will contain entries for exception handlers, hardware interrupt handlers, and the system call handler. Each entry in the IDT has a Descriptor Privilege Level (DPL) that specifies the privilege level needed to use that descriptor. Hardware interrupt handlers and exception handlers should have their DPL set to 0 to prevent user-level applications from calling into these routines with the int instruction. The system call handler should have its DPL set to 3 so that it is accessible from user space via the int instruction. Finally, each IDT entry also contains a segment selector field that specifies a code segment in the GDT, and you should set this field to be the kernel’s code segment descriptor. When the x86 sees that a new CS is specified, it will perform a privilege switch, and the handler for the IDT entry will run in the new privilege level. This way, the system call interface is accessible to user space but the code executes in the kernel. ## Appendix E: Stack Switching and the TSS # The last detail of user space to kernel transitions on system calls, interrupts, or exceptions is stack switching. The stack switch is taken care of by the x86 hardware. The x86 processor supports the notion of a task; this hardware support is encapsulated in a Task State Segment, or TSS. You will not use the full x86 hardware support for tasks in this project, but the x86 requires that you set up one TSS for, among other things, privilege level stack switching. The TSS in the given code is a placeholder. Read the Intel manuals for details on the fields in it; the important fields are 880 and ESPO. These fields contain the stack segment and stack pointer that the x86 will put into SS and ESP when performing a privilege switch from privilege level 3 to privilege level 0 (for example, when a user-level program makes a system call, or when a hardware interrupt occurs while a user-level program is executing). These fields must be set to point to the kernel’s stack segment and the process’s kernel-mode stack, respectively. Note that when you start a new process, just before you switch to that process and start executing its user-level code, you must alter the TSS entry to contain its new kernel-mode stack pointer. This way, when a privilege switch is needed, the correct stack will be set up by the x86 processor. ## Appendix F: Signals # For extra credit, your OS can provide an infrastructure for user-level signals, similar to Linux. The table details the signals that will be supported. Signal Name Signal Number Default Action DIV_ZERO 0 Kill The Task SEGFAULT 1 Kill The Task INTERRUPT 2 Kill The Task ALARM 3 Ignore USER1 4 Ignore The set_handler system call changes the default action taken when a signal is received: the signum parameter specifies which signal’s handler to change, and the handler-address points to a user-level function to be run when that signal is received. It returns 0 if the handler was successful set, and -1 on failure. If handler-address is NULL (zero), the kernel should reset the action taken to be the default action. DIV_ZERO should be sent to a task when the x86 processor generates a divide-by-zero exception while executing user-level code. SEGFAULT should be sent when any other exception occurs, including any illegal instructions, illegal memory references, page faults, general protection faults, illegal opcodes, etc. The INTERRUPT signal should be sent when a CT RL+C is pressed on the keyboard. The ALARM signal should be sent to the currently-executing task (there is only one currently-executing task in this OS) every 10 seconds. This should be implemented by knowing at what rate the RTC’s Periodic Interrupts occur, counting how many Periodic Interrupts have occurred, and sending an ALARM signal after 10 seconds have elapsed. Finally, USER1 is user-defined and can be used to implement any other signal of your choosing. Signals should only be delivered to a task when returning to user space from the kernel, so you’ll want to add some code in your return-to-user space linkage to check for pending signals. To support signal delivery, you should use a mechanism similar to what Linux uses: 1. Mask all other signals. 2. Set up the signal handler’s stack frame. You’ll need the current value of the user-level ESP register to find the user’s current stack location. The signal handler stack frame goes directly above this on the stack. The signal handler stack frame is shown in Figure 1. Setting up the signal handler stack frame involves: copying a return address and a signal number parameter to the user-level stack, copying the process’s hardware context (see Figure 2) from the point when the program was interrupted for the signal, and copying a small amount of assembly linkage to the user-level stack that calls sigreturn when the signal handler is finished. 3. Finally, execute (in user space) the handler specified in the signal descriptor. No other information needs to be passed to the signal handler (no siginfo_t structure like the modern Linux signals). When the user-level signal handler returns, it will use the return address you have copied on its stack, which will jump to the assembly linkage (also on the stack). This assembly linkage should make the sigreturn system call (using the standard int$0x80 user-level system call calling convention).

The sigreturn system call should copy the hardware context that was on the user-level stack back onto the processor. To find the hardware context, you will need to know the user-level value of ESP (will be saved by your system call handler) as well as the exact setup of the user-level stack frame. To copy the hardware context back onto the processor, you will actually overwrite the kernel’s copy of the process’s hardware context that was saved on the kernel stack when it handled the sigreturn system call. In this way, when the sigreturn system call handler returns to user space, the hardware context will automatically be copied back onto the processor by your return-from-kernel code that you have already written. One thing to be careful of: you’ll probably have system calls set up to return a value (in EAX) to user space. Be sure you don’t clobber the user’s EAX value from its hardware context with a bogus “return value”

From sigreturn - have sigreturn return the hardware context’s EAX value so that you won’t have to special-case the return from sigreturn.

Shown in Figure 2 is a slightly-modified version of the struct pt_regs structure that Linux uses for its hardware context; this modified structure is what you should use in this MP. The “Error Code / Dummy” field has been added to the hardware context to simplify exception handling. For some exceptions, the processor pushes an error code onto the stack after XCS (for example, page faults do) whereas other exceptions do not (divide-by-zeros do not). For exceptions that do not push this error code, your exception handler should push a dummy value to take up the error code slot3. x86 interrupts never push the error code, so you must also push a dummy value in all of your interrupt handlers and the system call handler. You can find documentation about which exceptions push error codes (and much more about exceptions) in Volume 11: System Programming of the Intel ISA manual on the Tools, References, and Links section of the website.

Finally, signal handling information should go in the process control block (PCB). You will need to keep track of pending signals, masked signals, and handler actions / addresses for each signal. Much information on Linux’s implementation of signals (which your implementation will closely match) can be found in Understanding the Linux Kernel chapter 10.

## Alternative (with video) #

Please watch this introductory video to linux kernels before you begin.

There is no lab assignment, just do the review. It will be graded for completion.


text:
mersenneforum.org Factoring humongous Cunningham numbers
 Register FAQ Search Today's Posts Mark Forums Read

2012-03-29, 19:40   #1013
xilman
Bamboozled!

"𒉺𒌌𒇷𒆷𒀭"
May 2003
Down not across

3×3,529 Posts

Quote:
 Originally Posted by jyb Lest I be accused of poaching, I should point out that 11-7,211 wasn't me. I think Warut did that one as well. On the other hand, your report is missing 7+5,280, so maybe Warut did that one. Either way, it wasn't me.
Never ascribe to malice that which is adequately explained by incompetence. I almost certainly screwed up and I'll try to correct the tables tomorrow.

Thanks for the report.

Paul

2012-04-05, 12:08   #1014
R.D. Silverman

Nov 2003

22·5·373 Posts

Quote:
 Originally Posted by xilman Never ascribe to malice that which is adequately explained by incompetence. I almost certainly screwed up and I'll try to correct the tables tomorrow. Thanks for the report. Paul
There are numbers (relatively small) that have been reserved for over 9
months. In one instance, a quite small number has been reserved for
over 15 months!

Shouldn't these be released??????

2012-04-05, 13:30   #1015
xilman
Bamboozled!

"𒉺𒌌𒇷𒆷𒀭"
May 2003
Down not across

3×3,529 Posts

Quote:
 Originally Posted by R.D. Silverman There are numbers (relatively small) that have been reserved for over 9 months. In one instance, a quite small number has been reserved for over 15 months! Shouldn't these be released??????
Not sure whether Tom has seen this post yet. I'll give him a while and then contact him if needed.

On the face of it, it sounds like they should be released.

Paul

2012-04-05, 16:43   #1016
jyb

Aug 2005
Seattle, WA

23×11×19 Posts

Quote:
Originally Posted by xilman
Quote:
 Originally Posted by R.D. Silverman There are numbers (relatively small) that have been reserved for over 9 months. In one instance, a quite small number has been reserved for over 15 months! Shouldn't these be released??????
Not sure whether Tom has seen this post yet. I'll give him a while and then contact him if needed.

On the face of it, it sounds like they should be released.

Paul
For cleanliness reasons I tend to agree. But then I have to wonder if it really matters. There are tons of available composites, and it doesn't really affect anybody if some are "off the market" (does it?)

In any case, I suspect Al has forgotten about his reservations. He hasn't posted in the forum in quite some time; but he did respond to PMs a few months ago, so you could probably just ask him about them. As for the longest reservation, I have no idea. It should be about a 1-day job at this point.

2012-04-05, 17:43   #1017
fivemack
(loop (#_fork))

Feb 2006
Cambridge, England

2·3,191 Posts

Quote:
 Originally Posted by R.D. Silverman There are numbers (relatively small) that have been reserved for over 9 months. In one instance, a quite small number has been reserved for over 15 months! Shouldn't these be released??????
I am willing to rely on peoples' natural propensity to poach at this stage; it's not as if there's a shortage of numbers.

2012-04-10, 01:45   #1018
FactorEyes

Oct 2006
vomit_frame_pointer

23×32×5 Posts
I was just borrowing these numbers

Quote:
 Originally Posted by fivemack I am willing to rely on peoples' natural propensity to poach at this stage; it's not as if there's a shortage of numbers.
I am the scofflaw-in-chief as to the statutes prohibiting gratuitously long reservation times.

I have blown the dust off a couple of motherboards and replaced some fans with sodomized bearings. Will be seiving starting tonight.

2012-04-10, 01:52   #1019
Batalov

"Serge"
Mar 2008
Phi(4,2^7658614+1)/2

100100011100002 Posts

Quote:
 Originally Posted by FactorEyes ..some fans with sodomized bearings. Will be seiving starting tonight.
Glad to hear that the infamous bolt pistol device is fully functional.

 2012-04-25, 16:34 #1020 xilman Bamboozled!     "𒉺𒌌𒇷𒆷𒀭" May 2003 Down not across 3·3,529 Posts Another nine factors found in the last month or so: Code: 11+6 221 C176 10435949886951322339843206060956949620180087. C133 M Steine SNFS 2012-04-07 11+6 221 C133 24767475435884355535772121180512210248147314666213049529. P78 M Steine SNFS 2012-04-07 9+8 253 C154 4467473834576280546309861462651386238756638483. P109 J Becker ECM 2012-04-08 11+9 214 C138 556682702077050316316255715332715524223321010546267200589. P82 R Dickerson GNFS 2012-04-09 7-3 289 C188 2420852073079507622575068368998757292303171749. C142 J Becker ECM 2012-04-10 9-5 257 C192 870607599185891315985630351779578342811273382801541. P141 J Becker ECM 2012-04-12 7-6 289 C146 599654246393515709772207614725463793557918462357599451. P92 A Edwards GNFS 2012-04-21 7+5 286 C136 982002498511527034012011605941705349643386445868584613. P82 J Becker ECM 2012-04-24 8+5 233 C137 59401448311810488784199604151205801229756021761002933418088735758971. P69 R Dickerson GNFS 2012-04-24 There are now 561 composites left in the tables. Paul P.S. My ISP seems to be refusing ftp uploads at the moment so the tables may not appear on the web for a little while. Last fiddled with by xilman on 2012-04-25 at 16:37 Reason: Add P.S.
2012-04-25, 16:38   #1021
R.D. Silverman

Nov 2003

11101001001002 Posts

Quote:
 Originally Posted by xilman Another nine factors found in the last month or so: Code: 11+6 221 C176 10435949886951322339843206060956949620180087. C133 M Steine SNFS 2012-04-07 11+6 221 C133 24767475435884355535772121180512210248147314666213049529. P78 M Steine SNFS 2012-04-07 9+8 253 C154 4467473834576280546309861462651386238756638483. P109 J Becker ECM 2012-04-08 11+9 214 C138 556682702077050316316255715332715524223321010546267200589. P82 R Dickerson GNFS 2012-04-09 7-3 289 C188 2420852073079507622575068368998757292303171749. C142 J Becker ECM 2012-04-10 9-5 257 C192 870607599185891315985630351779578342811273382801541. P141 J Becker ECM 2012-04-12 7-6 289 C146 599654246393515709772207614725463793557918462357599451. P92 A Edwards GNFS 2012-04-21 7+5 286 C136 982002498511527034012011605941705349643386445868584613. P82 J Becker ECM 2012-04-24 8+5 233 C137 59401448311810488784199604151205801229756021761002933418088735758971. P69 R Dickerson GNFS 2012-04-24 There are now 561 composites left in the tables. Paul
I sent the following factor of 5^338 + 2^338 to you by email several
days ago. Did you not get it?

409399004979607621012328314095551469164618786368901

2012-04-25, 17:06   #1022
xilman
Bamboozled!

"𒉺𒌌𒇷𒆷𒀭"
May 2003
Down not across

3·3,529 Posts

Quote:
 Originally Posted by R.D. Silverman I sent the following factor of 5^338 + 2^338 to you by email several days ago. Did you not get it? 409399004979607621012328314095551469164618786368901
Unfortunately not. The last I have from you was for 7+3,289 back in late March.

I'll update the tables with that one. My ISP is now accepting ftp uploads again.

Paul
P.S. Now uploaded. I guessed it was found by ECM but it it's wrong let me know and I'll correct it on the next update.

Last fiddled with by xilman on 2012-04-25 at 17:13 Reason: Add P.S.

 2012-05-25, 09:29 #1023 Yamato     Sep 2005 Berlin 2·3·11 Posts I got a P51 out of 4^407+3^407, thanks to ECM. Run 89 out of 200: Using B1=60000000, B2=2383761580216, polynomial Dickson(30), sigma=3786633027 Step 1 took 172163ms Step 2 took 172864ms ********** Factor found in step 2: 608118898001708651481623295373928558944853611010443 Found probable prime factor of 51 digits: 608118898001708651481623295373928558944853611010443 Probable prime cofactor ((4^407+3^407)/(7*727*859*10642237*3581788849*2698559459 340638836021*1867633762794238828781932446139620619))/608118898001708651481623295373928558944853611010443 has 114 digits

 Similar Threads Thread Thread Starter Forum Replies Last Post wpolly Factoring 26 2016-07-29 04:34 Xyzzy Cunningham Tables 42 2014-04-02 18:31 jasong GMP-ECM 6 2006-06-30 08:51 jasong Factoring 1 2006-04-03 17:18 jasong Factoring 27 2006-03-21 02:47

All times are UTC. The time now is 21:05.

Tue Mar 2 21:05:47 UTC 2021 up 89 days, 17:17, 0 users, load averages: 1.86, 1.85, 1.86


text:
# Thread: Difference between base and ordered base

1. ## Difference between base and ordered base

I don't understand what is the difference between a base and an ordered base of a vectorial space. Can you give me an example of a base and ordered base over a same vectorial space, say $\mathbb{R}^2$?

2. Thank you for the link, but I've already read it before and it doesn't provide a concrete example as I'd like.
Say I have the base $\{ (0,1), (1,0) \}$ that generates $\mathbb{R}^2$ I think. Is it an ordered base? I'm not even sure it generates $\mathbb{R}^2$ but I think yes since I can write any vector of $\mathbb{R}^2$ as combination of the 2 vectors forming the base.

3. By the way, I update solution $W^{\perp} \cap W$ of last question due to some mistake.
Did you know ?

4. Originally Posted by math2009
By the way, I update solution $W^{\perp} \cap W$ of last question due to some mistake.
Did you know ?
Do you mean in this thread : http://www.mathhelpforum.com/math-he...ersection.html ?
Thank you for all your help!


text:
How do you simplify 2sqrt6+9sqrt6?

$11 \sqrt{6}$
Consider the example: $2 a + 9 a = 11 a$
We have the same thing but instead of $a$ we have $\sqrt{6}$
So $2 \sqrt{6} + 9 \sqrt{6} = 11 \sqrt{6}$


text:
# Modeling Using Differential Equations

## Homework Statement

Suppose the rate at which the volume in a tank decreases is proportional to the square root of the volume present. The tank initially contains 25 gallons, but has 20.25 gallons after 3 minutes. Solve for the general solution (do not solve for V).

## The Attempt at a Solution

dV/dt = k√(V)

That's as far as I got. I know I have to "separate" the variables and whatnot, but there is no 't' to separate and differentiate from. I guess the equation would be: ∫1/√(V) dV = k∫ ___ dt
So my question is, since there is no 't' in the equation, what do I differentiate instead?

your setup is correct, k is just some constant and whenever you integrate a constant with respect to x, t, z, etc. your left with k multiplied by the variable you integrated with respect to
so in your case, for the RHS youll get kt+C

your setup is correct, k is just some constant and whenever you integrate a constant with respect to x, t, z, etc. your left with k multiplied by the variable you integrated with respect to
so in your case, for the RHS youll get kt+C
That's what I thought. I just wanted to double check. Thanks!

I have another question (actually 3 questions):

3) Use the initial condition to find the constant of integration, then write the particular solution (do not solve for V).

Attempt at solution: 2√(25)=k(0) + C

4) Use the second condition to find the constant of proportion.

Attempt at solution: 2√(20.25)=k(3) + 10 --> 4=3k+10 --> -6=3k


text:
I got robbed for the fifth time today

Yup. I didn’t buy a lock for the gym locker, apparently my wallet “fell out”, and today I received two notifications from my credit card that I bought a Subway sandwich for \$12.01 and got a MetroCard for \$40.00.

Every time I (or my family) get robbed, I (or my mom and dad) put in processes to make sure that it doesn’t happen again. This means every robbery is different:

• Home invasion (get additional bolts for house, build fence, get security cameras, get motion sensor tripped floodlights)
• Car break-in (make sure purse and valuables are kept out of sight from car windows)
• Mugging (don’t wear anything valuable in public, keep a can of pepper spray or mace and practice using it)
• Identity theft (freeze credit reports, change banks, place long-term credit freeze)
• Petty theft / larceny (buy a darn lock)

Every time I get robbed I hate it just a bit more. The first time I was robbed, I slept like a baby because I knew the robbers would likely avoid re-combing an area they swept clean. Today I screamed in the hallway because I hate being robbed so much.

But you know what? Every time I get robbed, I deal with it a bit better. I went to the bank, cancelled all my cards, came back to the office, screamed it out, and went to our wellness room to meditate a little. Then I worked until 8PM on this one pressing issue. Then I went to the gym and let them know that somebody’s been stealing things. Then I went and bought some green tea using an app on my phone. And everything seemed fine.

Of course it’s not fine. I’m honest with myself on that. I hate robbers the more times they steal from me and the more money they take (I lost \$56 in hard cash, which was all the cash I had, and 20x less than the last time I got robbed, where a third of my net worth disappeared).

But I would say it gives me an opportunity to deal with a stressful situation better than the last time, and on that mark I like to think I’m improving. This is important because healthy ways to deal with stress, just like dealing with heights or other kinds of fears, will be important for me going forward. It’s important to have these weeds in your life because it’s how you grow more fully in your understanding of the world and your empathy with other people dealing with similar or worse things.

I take comfort in believing that any thief can take my money, or my treasures I possess in this world, but no thief can take away who I am, as long as I don’t let them. I like to keep it that way.