text:
Neil Blakey-Milner
45 posts
ALSA sound experience/interest?
I've just added some very dodgy ALSA sound support to my Linux/xcb platform layer:

This is the first time I've tried anything to do with sound at this level, so I'm just surprised I got something that mostly works most of the time. It has buffer underruns and more latency than I would like.

It would be awesome if someone with ALSA sound experience could help out - or even just someone interested in learning about it in the deep end.

Thanks!
Christopher
17 posts
ALSA sound experience/interest?
Edited by Christopher on
I just started working on ALSA for my Common Lisp implementation. I'm going the MMAP_INTERLEAVED route, but I'm mostly basing it off of the pcm.c sine wave generator provided in test/pcm.c of the alsa tar-file on the download page.

I also found this document which uses the read/write method that I think you are using:

http://users.suse.com/~mana/alsa090_howto.html

But I didn't read it too much! Good luck :)
Neil Blakey-Milner
45 posts
ALSA sound experience/interest?
I look forward to seeing your code - I wanted to use MMAP_INTERLEAVED simply because then I could more easily use Casey's Win32 audio code as a template on what to do. But the play/write cursor idea doesn't seem to map directly to MMAP_INTERLEAVED, reducing that benefit, and I could find no useful documentation on it (but then, there isn't anything useful on using snd_pcm_writei in the game/low-latency case, mostly just the music file playback case with ~1-2s of write-ahead).

Cheers!

Neil
Christopher
17 posts
ALSA sound experience/interest?
I'll see what I can do in the next day or so! I feel pretty close.
Christopher
17 posts
ALSA sound experience/interest?
Alright so I managed to get a sound test working (it totally dis-regards important errors right now, so don't use this please!).

https://gist.github.com/chebert/a501fc6c67b4ae406eb4

It's not working with Xlib yet (sound is super choppy) so that's next on the list. then at least enough error handling to re-start the sound for buffer over/under runs.

As to the playCursor writeCursor thing that casey does, I think that gets taken care of by ALSA? It seems like the
 1 while (> size 0)

takes care of looping over the regions to write to.


text:
# Thread: Solution of 4t dy/dt + y = t^3

1. ## Solution of 4t dy/dt + y = t^3

The question is attached (along with the answer). It's asking me to guess the solution of this differential equation. I think I would have to use the reduction of order method if I were given a particular solution but I am not given one. I'm assuming there is a logical way to guess this rather than just randomly guessing in a brute force manner. Could someone explain to me what the thought process is for this?

2. ## Re: Solution of 4t dy/dt + y = t^3

Originally Posted by s3a
The question is attached (along with the answer). It's asking me to guess the solution of this differential equation. I think I would have to use the reduction of order method if I were given a particular solution but I am not given one. I'm assuming there is a logical way to guess this rather than just randomly guessing in a brute force manner. Could someone explain to me what the thought process is for this?

Am not sure how helpful this will be but the problem is of the type Cauchy-Euler

Cauchy

This will at leat give you something to look up.

I will also give two ideas:

Idea 1: Solve the homogenous problem first.

$4ty'+y=0 \iff \frac{dy}{y}=-\frac{1}{4}\frac{dt}{t} \implies \ln(y)=-\frac{1}{4}\ln(t)+C \implies y=\frac{c}{t^{1/4}}$

Now find the particular solution by guessing it is a Monomial of degree 3. (do you see what it cannot have any lower degree terms.)

Idea 2
Let $y=f(u), u=\ln(t)$

Then $\frac{dy}{dt}=\frac{df}{du}\frac{du}{dt}=\frac{1}{ t}\frac{df}{du}$

This will transform the equation into

$4t\left( \frac{1}{t}\frac{df}{du}\right)+f(u)=e^{3u} \iff 4f'+f=e^{3u}$

This is a first order linear differential equation with contant coeffiencts.

Just FYI the usual "guess" is $y=At^n$

format: plain


text:
## Conceptual Physics (12th Edition)

Published by Addison-Wesley

# Chapter 8 - Plug and Chug: 43

#### Answer

It will double. The angular momentum is proportional to speed.

#### Work Step by Step

Angular momentum $= mvr = (80 kg)(6 m/s)(2 m) = 960 \frac {kg \cdot m^{2}}{s}$.

After you claim an answer you’ll have 24 hours to send in a draft. An editor will review the submission and either publish your submission or provide feedback.


text:
# precise definition of “moduli space”

I'm curious what the precise definition of the moduli space of a QFT is. One often talks about the classical moduli space, which then can get quantum corrections. Does this mean the quantum moduli space is something like the set of minima of the effective potential in the 1PI action (or does the 1PI action already presume a choice of vacuum?)? Is there a non-perturbative definition, without referring to field configurations or effective actions (eg, how do we define it in string theory, where there are no fields)? Maybe it can be identified with some submanifold of the (projective) Hilbert space? Can the metric or other structure be defined in such an invariant way?

-

The most accurate and most quantum definition is that it is the set of all maximally symmetric states (preserving the spacetime symmetries of the flat space or de Sitter space or anti de Sitter space if one allows gravity) in the extended Hilbert space – or one connected component of such a space. By the extension, I mean the formal union of all the superselection sectors.

Equivalently, one may consider the moduli space in QFT to be the set of all superselection sectors that include the maximally supersymmetric ground state.

It just happens that one may associate each such maximally symmetric state with a stationary point (minimum) of the effective action and it is indeed the 1PI effective action. We also talk about the Wilsonian, low-energy effective actions which are conceptually important but they're not an accurate tool to describe the moduli spaces; see some uncontroversial comments about the "right effective action to be used" written by my ex-adviser in his otherwise controversial paper

http://arxiv.org/abs/hep-th/0412129

It's often the case that we know exactly what decides about the fate of the moduli space. In most cases, the theory admits a classical limit and the true moduli space has to be a "deformation" of the classical moduli space – the set of solutions to the classical equations. However, the potential may be modified by quantum corrections that may lift the degeneracy and lower the dimension of the Hilbert space (or set it to zero).

Also, as the ${\mathcal N}=2$ supersymmetric gauge theories show, the quantum effects may introduce monodromy and change the topology of the moduli space etc.

-
Thanks for the answer. So let me see if I understand. A point in moduli space is associated to certain superselection sectors, which in turn are classically associated to the asymptotic values of the fields. In some of these sectors there is a vacuum state (annihilated by the poincare generators), with excitations above it described by the effective theory about that point in moduli space. Perturbatively, one finds a saddle point with the given asymptotic behavior and quantizes perturbations around it. Still a little confused about what the superselection sectors are quantum mechanically. –  user6013 Apr 25 '12 at 1:10
Right! And concerning the last question, superselection only make sense quantum mechanically. en.wikipedia.org/wiki/Superselection_sector –  Luboš Motl Apr 25 '12 at 4:04


text:
Linear Algebra References - Maple Programming Help

Home : Support : Online Help : System : Information : References : linalg(deprecated)/references

Linear Algebra References

Important: The linalg package has been deprecated. Use the superseding packages, LinearAlgebra and VectorCalculus, instead.

General References for linalg Routines

 Golub, Gene H., and Van Loan, Charles F. Matrix Computations. Baltimore: Johns Hopkins University Press, 1989. 642 pp.
 Schey, Harry. Div, Grad, Curl, and All That; an Informal Text on Vector Calculus. New York: Norton, 1973. 163 pp.
 Strang, Gilbert. Linear Algebra and its Applications. 3rd ed. San Diego: Harcourt, Brace, Jovanovich Publishers, 1988. 505 pp.

Reference for gaussjord and rref

 Noble, Benjamin, and Daniel, James. Applied Linear Algebra. 3rd ed. Englewood Cliffs, New Jersey: Prentice Hall, 1988. 521 pp.

Reference for frobenius and jordan

 Ozello, Patrick. "Calcul exact des formes de Jordan et de Frobenius d'un matrix." Doctoral Thesis, 1987.

 Goldstein, A.J., and Graham, R.L. "A Hadamard-Type Bound on the Coeffs of a Determinant of Polynomials." SIAM Review, Vol. 16. (1974): 394-395.

Reference for hermite, ihermite, smith, and ismith

 Kannan, Ravindran, and Bachem, Achim. "Polynomial Algorithms for Computing the Smith and Hermite Normal Forms of an Integer Matrix." SIAM Journal of Computing, Vol. 8 No. 4. (November 1979): 499-507.


text:
Browse Questions

Two masses $M_1$ and $M_2$ are attached to end of a string which passes over a pulley attached to the top of a double inclined plane. If $M_1$ and $M_2$ are $5 kg$ each. and the base angles are $30^{\circ}$ each. The tension in the string.

$(a)\;20\;N \quad (b)\; 25\;N \quad (c)\; 50\;N \quad (d)\;100\;N$

Tension $T=mg \sin \theta$
$\qquad=50 \times \large\frac{1}{2}$
$\qquad=25 \;N$
Hence b is the correct answer.

edited Jan 26, 2014 by meena.p


text:
Required field
Required field
Required field
Required field

# Validation Case: RUB Wind Tunnel Tests Validated Against Lattice Boltzmann Method-SimScale

This document provides a comparison of computational fluid dynamics (CFD) simulation results done with the lattice Boltzmann method (LBM) in SimScale with RUB wind tunnel tests conducted by two German research institutes.

## Overview

Wind tunnel testing has been in use as an experimental tool to observe the effects of wind on buildings$$^1$$. The use of wind tunnels is not only beneficial for the architectural industry, but also in the aviation, construction, and automotive fields. However, the rise in computational power and the development in computational analysis makes CFD a fast and cost-efficient addition to wind tunnel testing, especially in the early design stages.

Wind analysis results obtained from CFD simulation can be seen as trusted sources of qualitative and quantitative data, as they are used in making important design decisions. One method that can be employed is the lattice Boltzmann method. This method has gained popularity in the last two decades as an alternative to conventional CFD methods such as the finite volume method (FVM) and the finite difference method (FDM).

The advantages of running a simulation with the LBM method compared to conventional CFD methods are that it can handle extremely complex geometries better and its efficient parallelization in combination with the use of graphical processing units (GPUs) makes it suitable for large transient simulations. This makes LBM an attractive option, especially when combined with cloud computing, as it is becoming more accessible and powerful. The LBM solver implemented in SimScale is Pacefish$$^®$$ developed by Numerics Systems GmbH.

In order to have full confidence in the simulation results, comprehensive validations and verifications of CFD results are necessary. With this in mind, at SimScale we validate all released major features by comparing the simulation results to analytical or experimental data. Therefore, in this article, we have provided a comparison of two wind tunnel results with a simulation done in SimScale using LBM.

## Wind Tunnel Tests

The wind tunnel tests are based on a study done by C.Kalender with the title “Vergleich Unabhängiger Experimenteller Ausbreitungs-untersuchungen In Einem Fiktiven Stadtmodell“$$^2$$.

The wind tunnel results used for validation were taken from two different institutions:

• IFI: ABL Wind Tunnel, Institut für Industrie-aerodynamik (IFI), Aachen. The experiment results from this institution will be later referred to as WT1.
• WIST: ABL Wind Tunnel, Arbeitsgruppe Windingenieurwesen und Strömungsmechanik (WIST), Ruhr-Universität Bochum. The experiment results from this institution will be later referred to as WT2.

## Geometry

We used the following models taken from the wind tunnel experiments:

Both models have a scale of 1:200. In order to be able to validate the lattice Boltzmann solver, we recreated the scaled model as a computer CAD model and the specifications of the virtual wind tunnel size are tabulated below:

The figure below shows the CAD model used for the simulation:

## Pre-Processing

The turbulence model used is k-Omega SST (DDES) so the simulation can switch between the Large Eddy Simulation (LES) and the RANS (Reynolds Averaged Navier Stokes) model. The simulation is a transient analysis for 3.6 fluid passes and the last 30% of the data are averaged for comparison with the results from the wind tunnel tests.

### Wind Direction and Measurement Points

Firstly, the wind direction used in this simulation is a 0° angle wind which can be seen below:

Additionally, we inserted probe points as done in the wind tunnel experiments as measurement points, and below is a table showing the coordinates of the probe points along with their names.

### Mesh

Next, we generated the mesh using Moderate fineness level and refined with Moderate refinements at the pedestrian level (0-0.02 $$m$$) and in areas in the proximity of measurement points MP14 and MP15. The number of cells and the minimum cell size can be seen in the table below:

Additionally, the mesh generated can be seen below:

### Boundary Conditions

For this study, the reference wind speed of 10 $$m/s$$ is considered at the reference height of 0.15 $$m$$ for the wind tunnel model. Furthermore, the velocities were normalized by this reference velocity for all simulation results.

We ran two simulations that are based on each test and used an atmospheric logarithmic boundary layer (ABL) profile based on each test. Firstly, the specifications of each test are in the table below:

Secondly, the ABL profile for the mean velocity and turbulence intensity was calculated with the formula below:

$$U = 10 \frac{ln(\frac{d-d_0}{z_0})}{ln(\frac{Z_{ref}-d_0}{d_0})}\tag{1}$$

$$I=\frac{1}{ln(\frac{d-d_0}{z_0})}\tag{2}$$

The graphical representation of velocity profile from each experiment can be seen below:

Finally, the graphical representation of the turbulence intensity profile applied in the simulations can be seen below:

## Results and Analysis

As stated before, the velocities are normalized for all results by the reference velocity. The velocity profile from each simulation and experiment is compared to observe the deviation of each result and serves as a comparison between the wind tunnel tests and simulations done with LBM.

### Results Comparison

The flow visualization and velocity plot can be observed below:

From a 0 degree angle, there is a good agreement between the simulation results and wind tunnel test results. 13 measurement points are within +/- 20 relative deviation to the wind tunnel results. The deviation from each simulation result compared to its corresponding wind tunnel experiment can be observed below:

When compared with WT1, 14 measurement points are within +/- 50 relative deviation to the wind tunnel results.

And when compared to WT2, 13 measurement points are within the +/- 50 relative deviation to the wind tunnel results.

### Results Analysis

A correlation analysis between the CFD simulation and the wind tunnel tests can be described in two numbers, the hit-rate criteria and the Pearson coefficient.

From the 0° angle, there is a good agreement between the CFD and wind tunnel test results because the hit-rate is higher than the criteria of 66% and a Pearson coefficient above 75%.

However, we can also see that the normalized velocity at MP14 does not agree with the wind tunnel results. This is due to the specific location of MP14 which is inside a separation region on top of the roof. The simulation results show a rather low mean velocity where the wind tunnel experiments indicate a velocity at approximately half of the freestream velocity. Possible reasons for the differences are:

• The simulation uses a steady inlet ABL profile, ignoring the transient fluctuations in turbulence and velocity at the inlet.
• The reference speed of 10 $$m/s$$ might be larger than the velocity used in the wind tunnel experiments, which leads to an increased separation region.

### Conclusion

In conclusion, the comparison provided above between the wind tunnel tests and simulations done with SimScale’s Pacefish® LBM solver integration produced comparable results.

References

• B. Kayışoğlu, et al.’Estimation of Wind Loads on Tall Buildings through Wind Tunnel Testing’.Oct. 2012.
• C. Kalender.’Vergleich Unabhängiger Experimenteller Ausbreitungs-untersuchungen In Einem Fiktiven Stadtmodell’.October.2019.
• Y. Lin, et al. ‘Research on Physical Wind Tunnel and Dynamic Model Based Building Morphology Generation Method’. May 2019.
• D. Phillips, et al, ‘Will CFD ever Replace Wind Tunnels for Building Wind Simulations?’.International Journal of High-Rise Buildings Volume 8 Number 2. June 2019.
• J. Zhang,.Lattice Boltzmann Method for Microfluidics: Models and Applications’.Microfluid Nanofluid 10:1-28,2011.
• Arumuga Perumal, D., Dass, Anoop K. ‘A Review on the Development of Lattice Boltzmann Computation of Macro Fluid Flows and Heat Transfer’. Alexandria Engineering Journal 54:955-971,2015.
• VDI.’VDI Richtlinie 3783 Blatt 9: Umweltmeteorologie Prognostische Mikrosckalige Windfieldmodelle Evaluierung für Gebäude- und Hinderniströmung’.November 2005.

Note


text:
View Single Post
 2019-04-04, 22:33 #1 EdH     "Ed Hall" Dec 2009 Adirondack Mtns 22·32·101 Posts How I Install and Run ecmpi Across Several Ubuntu Machines (Note: I expect to keep the first post of each of these "How I Install..." threads up-to-date with the latest version. Please read the rest of each thread to see what may have led to the current set of instructions.) This thread will explain the steps I use to install* ecmpi (by Cyril Bouvier) onto several computers which are already running Ubuntu. This procedure should work for other linux distributions as well but the only other one I've currently tested is Debain and I haven't gotten it to work with that OS, yet. *In this instance "install" is referring to the acquiring and compilation of the ecmpi package only. The binaries will have to be called using their respective paths. Special Note: I have found that I cannot get ecmpi to work past the host machine, on any combination involving 18.04, due to openmpi troubles. I will expect the user of these steps to be able to use the sudo command. For ecmpi to run, mpi or openmpi must be installed on the machines and all machines must have a user of the same name. I will use the name mpi for a standard user on all the machines in this thread. The necessary programs to be installed will need to be done so through an admin account prior to the installation of ecmpi at the mpi user level. I will use a directory called ecmpi and subdirectory ecmpi/work for these installations. You may elect to use names of your own choice. These instructions can be used as a reference only, if you want, but I will provide specifics that work for me. If you follow these steps as I provide them, you should end up with a working installation. First, follow the procedures in: How I Install GMP on my Ubuntu Machines and How I Install GMP-ECM on my Ubuntu Machines or, install GMP and ECM from the repositories. If you have already installed most of the following packages, you can skip them, however, notice I have added the packages git and three openmpi packages to the list. You will now need git to retrieve the latest version of ecmpi using my steps and openmpi is needed to distribute to other machines. Also, cmake will be needed to compile ecmpi. Open a terminal and enter: Code: sudo apt-get update You should be prompted for your password. This prompt should only appear once for your terminal session, unless you leave it idle for a long time. After the update completes and the user prompt reappears, enter: Code: sudo apt-get install g++ m4 zlib1g-dev make p7zip git openmpi-bin openmpi-common libopenmpi-dev cmake Accept the prompt. In order for the openmpi cluster to run properly with more than three total machines, every machine has to have free and clear communication with all others. In my case, using openssh, I had to make sure all keys were listed in the authorized_keys file on every machine and all machines were included in all known_hosts files. If you are already running openssh, then you should be able to achieve the two-way links between all your machines. If not, you should research openssh to cover all the details of making sure your systems are secure. As mentioned previously, all machines have to have a user with the same username. To accomplish this, go to System Settings>User Accounts and add your user. For this "How I" I'll use mpi as the new user and create a Standard account. Go ahead and password protect the new mpi user. If you will be using ssh, for each new mpi account, you will need to do all the ssh stuff to create keys and add them to all the other mpi accounts. Every time you add a new machine, you will need to add it to all the others and vice versa. At this point, if you're not already at a terminal in one of the mpi accounts, open one, either by logging in with the GUI, or possibly sshing in from one of the main accounts. Let's consider this mpi account to be the host. The rest will be slaves in our cluster. In the terminal (mpi@:~\$) enter the following: Code: git clone https://gite.lirmm.fr/bouvier/ecmpi.git ecmpi When this completes there should be a directory named ecmpi. Move into it with: Code: cd ecmpi Now, issue the following commands: Code: cmake ./ make If no errors appear, you should be all set to set up and test a working environment. The first thing is to create a hostfile that will hold the info for the host and all the slaves that will eventually be run. Create a file named hostfile within ecmpi and for now have one line which reads: Code: localhost slots=2 Now, create a directory called work within the ecmpi directory. and cd into it. Next, enter the following to test the setup: Code: mpirun -np 2 --hostfile ../hostfile ../ecmpi -q -N 1623678511619010615822065755621691733061933624824934705601768533043353 -nb 4 -B1 300000 The factors should be returned: Code: Results: 1623678511619010615822065755621691733061933624824934705601768533043353 = 1510114122412521897224212426928165813328765695962607 * 1075202521134668279 Note: Occasionally, the above will return unsolved. If this occurs, run it again and the factors should be found. To add slaves, go through the entire above procedure for each new machine and note their IP address. Perform all the ssh necessities and then add the new machine to the hostfile: Code: localhost slots=<# of cores> mpi@ slots=<# of cores> mpi@ slots=<# of cores> ... After each addition of a new machine, test the operation with the previous command, but vary the -np and -nb values. -np is the number of processes to be run simultaneously on the cluster. It must be <= the number of cores in the hostfile. -nb is the number of curves to be run. Last fiddled with by EdH on 2019-09-12 at 22:54


text:
# Rectangular Matrix

## Rectangular Matrix

Synonym for matrix with m rows and n columns, where mn.

Also a synonym for non-square matrix.

### Examples

The matrices A = $$\begin{pmatrix} a & e\\b & f\\c & g\\d & h\end{pmatrix}$$ and B = $$\begin{pmatrix} j & k & l\\m & n & o\end{pmatrix}$$ are rectangular matrices.


text:
• ASM Optimized routines 5 1
Currently:

### Author Topic: ASM Optimized routines  (Read 61153 times)

0 Members and 1 Guest are viewing this topic.

#### Xeda112358

• they/them
• Moderator
• LV12 Extreme Poster (Next: 5000)
• Posts: 4676
• Rating: +718/-6
• Calc-u-lator, do doo doo do do do.
##### Re: ASM Optimized routines
« Reply #105 on: June 18, 2021, 06:35:59 pm »
Wow, that's really neat. I don't have a use for that at the moment but I bet I can find one in some old, slow code.

How did you go about making the routine generator? I assume there are some simple rules it follows.
It looks through all the numbers 1-65535 to find some good code.
If the number is even, it essentially uses the code for n/2, but with an add hl,hl tacked on to the end. Otherwise it is odd and it first tries a shift-and-add algorithm (basically the classic, generic multiplication, but unrolled and with branches removed as we know which path it takes in advance). It registers whatever code it came up with, then it checks if it is faster or smaller to multiply by the factors (for example, it is faster to multiply by 27 by doing *3*9 or *9*3), so it finds all of the factors and checks for anything more efficient.

There are other tricks, too, like checking if it is faster to "negate" (i.e., *65535 is the same as *-1), and if there is a *(2^k-1) with k>3, it uses a subtraction. And it collapse things like 8 add hl,hl into ld h,l \ ld l,0, and has some pre-populated routines in the table.

It doesn't really know anything about the instruction set, so it can't do any fancy optimizations


text:
# A Desirable Extension of the Nerve Theorem

## Backgroud

The Nerve Theorem (see nLab;) asserts that given a finite collection $\cal K$ of compact sets with the property that all non empty intersections of sets in the family are homotopically trivial, then the union $X$ of the sets in the family is homotopically equivalent to the nerve $N({\cal K})$. Here the nerve of the family is the abstract simplicial complex that records the intersection pattern so if ${\cal K}=\{K_1,K_2\dots,K_n\}$ then $N({\cal K})=\{S \subset \{1,2,\dots,n\}: \cap\{K_i : i \in S\} \ne \emptyset$. The nerve theorem is attributed to Borsuk and Leray (and others). There are various variations. For example if you require that all non empty intersections are homologically trivial then the homology groups of the nerve are the same as those of $X$.

## The desired extension

Suppose that all non empty intersections of sets in $\cal K$ are homotopically equivalent to a single space $Z$. Under what conditions can you conclude that $X$ is homologically the same as the product of Z and the nerve.

This is usually not the case, so the question is to find conditions (as simple as possible) that will imply it.

Perhaps the kind of condition you would need is about sets in K intersecting "nicely". For example, we can define two sets A and B as "nicely intersecting" if the usual long exact Meyer-Vietoris sequence splits into short exact sequences. So you can require that every intersection of some sets in $\cal K$ intersect "nicely" every intersection of some other sets in $\cal K$. I don't have reason to believe that this is the definition required for the conclusion but it just illustrates what type of conditions are possible.

A possible application is indicated in this question.

Edit: Oscar Randal-Williams' answer shows that my suggestion for "nice" intersection is not sufficient for the desired conclusion. Perhaps the most interesting question in view of Oscar's result is this.

Suppose that you have a family $\cal > K$ of compact subsets of $latex R^d$ so that all non empty intersections of members of $\cal K$ are homotopically equivalent to to the same space $Z$ and every intersection of some sets in $\cal K$ intersect "nicely" every intersection of some other sets in $\cal K$, where "nice intersection" means that the Meyer-Vietoris long exact sequence splits. Is it true that the nerve of $\cal K$ has vanishing $i$th homology groups for $i>d$?

I think that a positive answer would suffice for the Helly-type application.

-

The condition you suggest is insufficient. For example, let $F \to E \overset{\pi}\to B$ be a fibre bundle, with compact fibre say, (or more generally a local quasi-fibration), and $\mathcal{K}_B$ be a cover of $B$ satisfying the conditions of the Nerve theorem (i.e. all intersections are empty or contractible). Then $$\mathcal{K} := \{ \pi^{-1}(K) \subset E \vert K \in \mathcal{K}_B \}$$ is a cover of $E$ satisfying your Mayer--Vietoris condition, and it is fairly clear that $$N(\mathcal{K}) = N(\mathcal{K}_B) \simeq B,$$ and $E$ will not typically be equivalent to $N(\mathcal{K}) \times F$ if the original bundle is not trivial.
So, to answer a different question: given a cover $\mathcal{K}$ of a space $X$ where all non-empty intersections are equivalent to $Z$, I think there will typically be a homotopy fibre seqeuence $$Z \to X \to N(\mathcal{K}).$$ Whether or not this is trivial is then another problem. By the example above, every local quasi-fibration arises is this way, so there is unlikely to be an especially simple description of when it is possible.
One condition that will give what you want is the following: if you can find a map $f : X \to Z$ such that for each non-empty intersection $K_\alpha = \cap_{i \in \alpha} K_i$ the map $f\vert_{K_\alpha}: K_\alpha \to Z$ is a homotopy equivalence, then $X \simeq Z \times N(\mathcal{K})$. This is probably much too strong for most applications through.
I should have been more careful. In my second paragraph, I should have said "given a cover $\mathcal{K}$ of a space $X$ such that all intersections are homotopy (or homology) equivalent to a space $Z$, and the inclusions between intersections are all homotopy equivalences, then there is a homotopy (or homology) fibre sequence..." In particular, this essentially forces the M-V condition to hold. – Oscar Randal-Williams Oct 25 '11 at 8:17


text:
# Structure from Motion (SfM)¶

Theia has a full Structure-from-Motion pipeline that is extremely efficient. Our overall pipeline consists of several steps. First, we extract features (SIFT is the default). Then, we perform two-view matching and geometric verification to obtain relative poses between image pairs and create a ViewGraph. Next, we perform global pose estimation with “one-shot” SfM (also called Global SfM).. One-shot SfM is different from incremental SfM in that it considers the entire view graph at the same time instead of successfully adding more and more images to the Model. One-shot SfM methods have been proven to be very fast with comparable or better accuracy to incremental SfM approaches (See [JiangICCV], [MoulonICCV], [WilsonECCV]), and they are much more easily parallelized. After we have obtained camera poses, we perform triangulation and BundleAdjustment to obtain a valid 3D reconstruction consisting of cameras and 3D points.

Extracting and matching Features has been covered already, so we will now discuss how to go from feature matches to a ViewGraph. First, however, we must present the basic building blocks for our SfM pipeline.

Additionally, while this documentation is a useful overview of the SfM pipeline we provide, there are many other useful methods that are not documented here that can be found in the theia/vision/sfm/ directory. All header and source files in Theia include extensive documentation.

## Views and Tracks¶

class View

At the heart of our SfM framework is the View class which represents everything about an image that we want to reconstruct. It contains information about features from the image, camera pose information, and metadata information (including the image name and EXIF data). Views make up our basic visiblity constraints and are a fundamental part of the SfM pipeline.

class Track

A Track represents a feature that has been matached over potentially many images. When a feature appears in multiple images it typically means that the features correspond to the same 3D point. These 3D points are useful constraints in SfM model, as they represent the “structure” in “Structure-from-Motion” and help to build a point cloud for our model.

## ViewGraph¶

class ViewGraph

A ViewGraph is a basic SfM construct that is created from two-view matching information. Any pair of views that have a view correlation form an edge in the ViewGraph such that the nodes in the graph are View that are connected by TwoViewInfo objects that contain information about the relative pose between the Views as well as matching information.

Once you have a set of views and match information, you can add them to the view graph:

std::vector<View> views;
// Match all views in the set.
std::vector<ViewIdPair, TwoViewInfo> view_pair_matches;

ViewGraph view_graph;
for (const auto& view_pair : view_pair_matches) {
const ViewIdPair& view_id_pair = view_pair.first;
const TwoViewInfo& two_view_info = view_pair.second;
// Only add view pairs to the view graph if they have strong visual coherence.
if (two_view_info.num_matched_features > min_num_matched_features) {
views[view_id_pair.second],
two_view_info);
}
}

// Process and/or manipulate the view graph.

The edge values are especially useful for one-shot SfM where the relative poses are heavily exploited for computing the final poses. Without a proper ViewGraph, one-shot SfM would not be possible.

## Camera¶

class Camera

Each View contains a Camera object that contains intrinsic and extrinsic information about the camera that observed the scene. Theia has an efficient, compact Camera class that abstracts away common image operations. This greatly relieves the pain of manually dealing with calibration and geometric transformations of images. We represent camera intrinsics such that the calibration matrix is:

$\begin{split}K = \left[\begin{matrix}f & s & p_x \\ 0 & f * a & p_y \\ 0 & 0 & 1 \end{matrix} \right]\end{split}$

where $$f$$ is the focal length (in pixels), $$s$$ is the skew, $$a$$ is the aspect ratio and $$p$$ is the principle point of the camera. All of these intrinsics may be accessed with getter and setter methods, e.g., double GetFocalLenth() or void SetFocalLength(const double focal_length). Note that we do additionally allow for up to two radial distortion parameters, but these are not part of the calibration matrix so they must be set or retrieved separately from the corresponding getter/setter methods.

We store the camera pose information as the transformation which maps world coordinates into camera coordinates. Our rotation is stored internally as an SO(3) rotation, which makes optimization with BundleAdjustment more effective since the value is always a valid rotation (unlike e.g., Quaternions that must be normalized after each optimization step). However, for convenience we provide an interface to retrieve the rotation as a rotation matrix as well. Further, we store the camera position as opposed to the translation.

The convenience of this camera class is clear with the common example of 3D point reprojection.

// Open an image and obtain camera parameters.
FloatImage image("my_image.jpg");
double focal_length;
CHECK(image.FocalLengthPixels(&focal_length));
const double radial_distortion1 = value obtained elsewhere...
const double radial_distortion2 = value obtained elsewhere...
const Eigen::Matrix3d rotation = value obtained elsewhere...
const Eigen::Vector3d position = value obtained elsewhere...

// Set up the camera.
Camera camera;
camera.SetOrientationFromRotationMatrix(rotation);
camera.SetPosition(position);
camera.SetFocalLength(focal_length);
camera.SetPrincipalPoint(image.Width() / 2.0, image.Height() / 2.0);

// Obtain a homogeneous 3D point
const Eigen::Vector4d homogeneous_point3d = value obtained elsewhere...

// Reproject the 3D point to a pixel.
Eigen::Vector2d reprojection_pixel;
const double depth = camera.ProjectPoint(homogeneous_point3d, &pixel);
if (depth < 0) {
LOG(INFO) << "Point was behind the camera!";
}

LOG(INFO) << "Homogeneous 3D point: " << homogeneous_point3d
<< " reprojected to the pixel value of " << reprojection_pixel;

Point projection can be a tricky function when considering the camera intrinsics and extrinsics. Theia takes care of this projection (including radial distortion) in a simple and efficient manner.

In addition to typical getter/setter methods for the camera parameters, the Camera class also defines several helper functions:.

bool InitializeFromProjectionMatrix(const int image_width, const int image_height, const Matrix3x4d projection_matrix)

Initializes the camera intrinsic and extrinsic parameters from the projection matrix by decomposing the matrix with a RQ decomposition.

Note

The projection matrix does not contain information about radial distortion, so those parameters will need to be set separately.

void GetProjectionMatrix(Matrix3x4d* pmatrix) const

Returns the projection matrix. Does not include radial distortion.

void GetCalibrationMatrix(Eigen::Matrix3d* kmatrix) const

Returns the calibration matrix in the form specified above.

Eigen::Vector3d PixelToUnitDepthRay(const Eigen::Vector2d& pixel) const

Converts the pixel point to a ray in 3D space such that the origin of the ray is at the camera center and the direction is the pixel direction rotated according to the camera orientation in 3D space. The returned vector is not unit length.

## Model¶

At the core of our SfM pipeline is an SfM Model. A Model is the representation of a 3D reconstuction consisting of a set of unique Views and Tracks. More importantly, the Model class contains visibility information relating all of the Views and Tracks to each other. We identify each View uniquely based on the name (a string). A good name for the view is the filename of the image that corresponds to the View

When creating an SfM reconstruction, you should add each View and Track through the Model object. This will ensure that visibility information (such as which Tracks are observed a given View and which Views see a given Track) stays accurate. Views and Tracks are given a unique ID when added to the Model to help make use of these structures lightweight and efficient.

class Model

Add a track to the model with all of its features across views that observe this track. Each pair contains a feature and the corresponding View name (i.e., the string) that observes the feature. A new View will be created if a View with the view name does not already exist. This method will not estimate the position of the track. The TrackId returned will be unique or will be kInvalidTrackId if the method fails.

bool RemoveTrack(const TrackId track_id)

Removes the track from the model and from any Views that observe this track. Returns true on success and false on failure (e.g., the track does not exist).

const Track* Track(const TrackId track_id) const
Track* MutableTrack(const TrackId track_id)

Returns the Track or a nullptr if the track does not exist.

std::vector<TrackId> TrackIds() const

Return all TrackIds in the model.

Adds a view to the model with the default initialization. The ViewId returned is guaranteed to be unique or will be kInvalidViewId if the method fails (e.g., if a view with that name already exists)

bool RemoveView(const ViewId view_id)

Removes the view from the model and removes all references to the view in the tracks.

Note

It is possible to have tracks of length 0 after this method is executed.

int NumViews() const
int NumTracks() const
const View* View(const ViewId view_id) const
View* MutableView(const ViewId view_id)

Returns the View or a nullptr if the track does not exist.

std::vector<ViewId> ViewIds() const

Return all ViewIds in the model.

ViewId ViewIdFromName(const std::string& view_name) const

Returns to ViewId of the view name, or kInvalidViewId if the view does not exist.

## Estimating Global Poses¶

Note

Documentation coming soon..

## Triangulation¶

Triangulation in structure from motion calculates the 3D position of an image coordinate that has been tracked through several, if not many, images.

bool Triangulate(const Matrix3x4d& pose1, const Matrix3x4d& pose2, const Eigen::Vector2d& point1, const Eigen::Vector2d& point2, Eigen::Vector4d* triangulated_point)

2-view triangulation using the method described in [Lindstrom]. This method is optimal in an L2 sense such that the reprojection errors are minimized while enforcing the epipolar constraint between the two cameras. Additionally, it basically the same speed as the TriangulateDLT() method.

The poses are the (potentially calibrated) poses of the two cameras, and the points are the 2D image points of the matched features that will be used to triangulate the 3D point. On successful triangulation, true is returned. The homogeneous 3d point is output so that it may be known if the point is at infinity.

bool TriangulateDLT(const Matrix3x4d& pose1, const Matrix3x4d& pose2, const Eigen::Vector2d& point1, const Eigen::Vector2d& point2, Eigen::Vector4d* triangulated_point)

The DLT triangulation method of [HartleyZisserman].

bool TriangulateMidpoint(const Eigen::Vector3d& origin1, const Eigen::Vector3d& ray_direction1, const Eigen::Vector3d& origin2, const Eigen::Vector3d& ray_direction2, Eigen::Vector4d* triangulated_point)

Perform triangulation by determining the closest point between the two rays. In this case, the ray origins are the camera positions and the directions are the (unit-norm) ray directions of the features in 3D space. This method is known to be suboptimal at minimizing the reprojection error, but is approximately 10x faster than the other 2-view triangulation methods.

bool TriangulateNViewSVD(const std::vector<Matrix3x4d>& poses, const std::vector<Eigen::Vector2d>& points, Eigen::Vector3d* triangulated_point)
bool TriangulateNView(const std::vector<Matrix3x4d>& poses, const std::vector<Eigen::Vector2d>& points, Eigen::Vector3d* triangulated_point)

We provide two N-view triangluation methods that minimizes an algebraic approximation of the geometric error. The first is the classic SVD method presented in [HartleyZisserman]. The second is a custom algebraic minimization. Note that we can derive an algebraic constraint where we note that the unit ray of an image observation can be stretched by depth $$\alpha$$ to meet the world point $$X$$ for each of the $$n$$ observations:

$\alpha_i \bar{x_i} = P_i X,$

for images $$i=1,\ldots,n$$. This equation can be effectively rewritten as:

$\alpha_i = \bar{x_i}^\top P_i X,$

which can be substituted into our original constraint such that:

$\bar{x_i} \bar{x_i}^\top P_i X = P_i X$
$0 = (P_i - \bar{x_i} \bar{x_i}^\top P_i) X$

We can then stack this constraint for each observation, leading to the linear least squares problem:

$\begin{split}\begin{bmatrix} (P_1 - \bar{x_1} \bar{x_1}^\top P_1) \\ \vdots \\ (P_n - \bar{x_n} \bar{x_n}^\top P_n) \end{bmatrix} X = \textbf{0}\end{split}$

This system of equations is of the form $$AX=0$$ which can be solved by extracting the right nullspace of $$A$$. The right nullspace of $$A$$ can be extracted efficiently by noting that it is equivalent to the nullspace of $$A^\top A$$, which is a 4x4 matrix.

Note

Docmentation coming soon...

## Similarity Transformation¶

void AlignPointCloudsICP(const int num_points, const double left[], const double right[], double rotation[3 * 3], double translation[3])

We implement ICP for point clouds. We use Besl-McKay registration to align point clouds. We use SVD decomposition to find the rotation, as this is much more likely to find the global minimum as compared to traditional ICP, which is only guaranteed to find a local minimum. Our goal is to find the transformation from the left to the right coordinate system. We assume that the left and right models have the same number of points, and that the points are aligned by correspondence (i.e. left[i] corresponds to right[i]).

void AlignPointCloudsUmeyama(const int num_points, const double left[], const double right[], double rotation[3 * 3], double translation[3], double* scale)

This function estimates the 3D similiarty transformation using the least squares method of [Umeyama]. The returned rotation, translation, and scale align the left points to the right such that $$Right = s * R * Left + t$$.

void GdlsSimilarityTransform(const std::vector<Eigen::Vector3d>& ray_origin, const std::vector<Eigen::Vector3d>& ray_direction, const std::vector<Eigen::Vector3d>& world_point, std::vector<Eigen::Quaterniond>* solution_rotation, std::vector<Eigen::Vector3d>* solution_translation, std::vector<double>* solution_scale)

Computes the solution to the generalized pose and scale problem based on the paper “gDLS: A Scalable Solution to the Generalized Pose and Scale Problem” by Sweeney et. al. [SweeneyGDLS]. Given image rays from one coordinate system that correspond to 3D points in another coordinate system, this function computes the rotation, translation, and scale that will align the rays with the 3D points. This is used for applications such as loop closure in SLAM and SfM. This method is extremely scalable and highly accurate because the cost function that is minimized is independent of the number of points. Theoretically, up to 27 solutions may be returned, but in practice only 4 real solutions arise and in almost all cases where n >= 6 there is only one solution which places the observed points in front of the camera. The rotation, translation, and scale are defined such that: $$sp_i + \alpha_i d_i = RX_i + t$$ where the observed image ray has an origin at $$p_i$$ in the unit direction $$d_i$$ corresponding to 3D point $$X_i$$.

ray_origin: the origin (i.e., camera center) of the image ray used in the 2D-3D correspondence.

ray_direction: Normalized image rays corresponding to model points. Must contain at least 4 points.

world_point: 3D location of features. Must correspond to the image_ray of the same index. Must contain the same number of points as image_ray, and at least 4.

solution_rotation: the rotation quaternion of the candidate solutions

solution_translation: the translation of the candidate solutions

solution_scale: the scale of the candidate solutions


text:
Hi all,

First time poster here, I've referenced posts here on daniweb in the past and it has always been helpful, thanks! But I can't find the answer to this particular problem here on the forums.

I need to write a basic string parser as part of a coding assignment here at penn state. I have completed the assignment using getc, but bonus points are offered for a solution using getline.

The getline() man page (http://linux.die.net/man/3/getline) requires stdio.h and stdlib.h for getline to compile.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
//welcome to main!
//we need our input values!

char inputstr[128];

while(1)
{
if(feof(stdin) != 0)
{ break; }

getline(&inputstr, 128, NULL);
//did that work!?
printf("input string is : %s\n", inputstr);
}

getc(stdin);
return 0;

}

This code wont even compile!!
Here is the compiler error and log, from Dev-C++(set for standard C)

LOG:

Compiler: Default compiler
Executing  gcc.exe...
gcc.exe "E:\pr1\proj1.c" -o "E:\pr1\proj1.exe"    -I"E:\Dev-Cpp\include"   -L"E:\Dev-Cpp\lib"
C:\DOCUME~1\xxxxxx\LOCALS~1\Temp/ccwrbaaa.o(.text+0x61):proj1.c: undefined reference to getline'
collect2: ld returned 1 exit status

Execution terminated

ERROR:

[Linker error] undefined reference to getline'
ld returned 1 exit status

Unfortunately, my go-to book, C:ARM(C a reference manual) doesnt even have this function! :(

Thanks for any help or insight you can provide!

-Tav

EDIT:

I realize that getline is not a standard C function, but even when I compile using

-std=c99

I get the same error!

Edited by taverasme: n/a

6
Contributors
8
Replies
36
Views
7 Years
Discussion Span
Last Post by Nikolas9896

Try something like below:

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{

char inputstr[128];
char *cptr = &inputstr[0];
size_t thesize = 128;

while(1)
{
if(feof(stdin) != 0)
{ break; }

getline(&cptr, &thesize, stdin);

printf("input string is : %s\n", inputstr);
}

getc(stdin);
return 0;

}

Or you could:

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main()
{
char *cptr = NULL;
size_t thesize = 0;

while(1)
{
if(feof(stdin) != 0)
{ break; }

getline(&cptr, &thesize, stdin);

printf("input string is : %s\n", cptr);

free(cptr);
cptr =  NULL;
}

getc(stdin);
return 0;

}

Edited by gerard4143: n/a

Try something like below:

With the MinGW version of gcc:

main.c
main.c: In function main':
main.c:18: warning: implicit declaration of function getline'
Debug/main.o: In function main':
C:/Users/Dave/Projects/scratch/main.c:18: undefined reference to _getline'
collect2: ld returned 1 exit status
*** Errors occurred during this build ***

I need to write a basic string parser as part of a coding assignment here at penn state. I have completed the assignment using getc, but bonus points are offered for a solution using getline.

Are they expecting you to then be using a *nux platform?

I realize that getline is not a standard C function, but even when I compile using

-std=c99

I get the same error!

Yes. It's not standard in either C90 or C99. ?

>>my go-to book, C:ARM(C a reference manual) doesnt even have this function!
because getline() is not a standard C function. Its a standard c++ function, not C. If your compiler implements a C getline() function than ok, but don't expect to read about it in any text book.

Linux man states

CONFORMING TO
Both getline() and getdelim() are GNU extensions. They are available
since libc 4.6.27.

Edited by gerard4143: n/a

Hi,i need help please,when i compile cpp file it give me error

main.cpp:158: error: 'getline' was not declared in this scope

i am newbie and i dont know what to do...i find some info about problems with getline on mac os x....the program run without problem in ubuntu but on os x i have this error.

Thanks.

First question, are you writing a C++ program or a C program? I ask because this is the C section and your error indicates a .cpp file.

Edited by gerard4143: n/a

Hello! How are can "free(cptr);" If you dosen't used to dynamic memorys?
You will helped -** man getline** - in this scope you could see how use that function.

Edited by Nikolas9896

This topic has been dead for over six months. Start a new discussion instead.
Have something to contribute to this discussion? Please be thoughtful, detailed and courteous, and be sure to adhere to our posting rules.


text:
# L'hospitals rulee major help

1. Mar 14, 2007

### angel_eyez

l'hospitals rulee!!! major help

1. i don't know how to do this question
limx->infinity (x/x+1)^x. i keep gettin the rong answer, some heelp plzz

2.the right answer is 1/e but im not getting that, i tried many diff ways, i cant post my work it here because its too long and confusing

3. The attempt at a solution
1. The problem statement, all variables and given/known data

2. Relevant equations

3. The attempt at a solution

2. Mar 14, 2007

### christianjb

Hint

Consider the series expansion for e^[1/x], when x is large.

3. Mar 14, 2007

### angel_eyez

umm so when x is large 1/x = 0 so that means e^o = 1, im still lossttt

4. Mar 14, 2007

### christianjb

Do you know the Taylor series for e^y, when y is small?

5. Mar 14, 2007

### angel_eyez

noo..havent learned it =S

6. Mar 14, 2007

### angel_eyez

i took the ln of both sides, and then found the derivative, and i got the answer as zero.. so i got ln y= 0
den i used the fact that e^lny = y...there fore y= e^0 =S..

7. Mar 15, 2007

### christianjb

Hmmm, I'm not sure how to do it without recourse to a Taylor series expansion. It's easy to prove though that

e^x=1+x+x^2/2!+x^3/3+....

Have you done Taylor series at all?

8. Mar 15, 2007

### angel_eyez

noo i haven't :|

9. Mar 15, 2007

### angel_eyez

kk thnnxx for your help newayzz =)

10. Mar 15, 2007

### christianjb

You suggested that L'hopital's rule should be used in the derivation. I played around with that and couldn't see it, but maybe someone else can work it out.

Let me know when you get the answer.

11. Mar 15, 2007

### Dick

You should have gotten something like x*ln(x/(x+1)) when you took the log. This is an infinity*0 form. To use L'Hopital you want to write it as 0/0 (or infinity/infinity). So write it as ln(x/(x+1))/(1/x). Now take derivative of the numerator and denominator and send x->infinity.

12. Mar 15, 2007

### dextercioby

There's no need for l'Hospital's rule, as this limit is elementary

$$\lim_{x\rightarrow \infty}\left(1-\frac{1}{x+1}\right)^{(x+1)\frac{x}{x+1}} =e^{-\lim_{x\rightarrow \infty}\frac{x}{x+1}}=e^{-1}$$

13. Mar 15, 2007

### christianjb

Dick, Brilliant!

14. Mar 15, 2007

### christianjb

That's supposing that you know the Taylor series expansion of e^x. It's nice that you can prove it a completely different way.

15. Mar 15, 2007

### Dick

Thanks. Wish I could say I invented it, but it's a pretty routine thing to do.

16. Mar 15, 2007

### dextercioby

Pardon me ? I just the definition of "e". What's more elementary than that ??


text:
Wheat is widely considered to be the world’s most important crop, and Norman Borlaug knew a thing or two about how to grow it. The US agronomist developed varieties that could better resist disease and gave higher yields. In doing so, he saved an estimated one billion people from starvation.

This week marks a century since Borlaug’s birth, so what better time to consider why millions still go hungry, and to ponder how the next Green Revolution can be kick-started? At a meeting in Mexico this week, organized by the International Maize and Wheat Improvement Center (CIMMYT) in collaboration with the Association for Agricultural Research and Experimentation of the State of Sonora, researchers will look again at the prospects for wheat. Although wheat consumption is growing, the investment needed to build on Borlaug’s legacy is scarce.

Wheat provides 20% of the dietary energy for the world’s population. Yet growth in yields has stagnated at around 0.9% per year over the past decade — by contrast, maize (corn) yields grow by almost double that at approximately 1.6% per year. To meet future demand for food, researchers say that wheat yields must grow by 1.7% each year. That will require investment. The total global spend on wheat breeding and research, around US$500 million per year, is currently one-quarter of that spent to improve maize. The discrepancy arises because seed companies can make higher profits from maize than from wheat. Maize is a hybrid crop that produces seeds with poor yields, so there is little incentive for farmers to keep and replant them. To get the best results, they must buy new maize seeds each year. Seed producers get no such annual income from wheat because farmers can reap and replant seeds from several successive harvests without losing much yield. Existing solutions to this are as much economic as agronomic. One strategy is for plant breeders to collect royalties from farmers who save seeds — as is done in countries such as Australia and the United Kingdom. Although this approach is reasonable for farmers who harvest substantial profits, it is less applicable to subsistence farmers in the developing world; for them, science might provide better solutions. An international research effort to boost wheat yields by 50% by 2035 will be officially launched at this week’s meeting. The International Wheat Yield Partnership — a consortium of research institutions including CIMMYT and the United Kingdom’s Biotechnology and Biological Sciences Research Council — is a long-term project that aims to raise US$100 million in the next five years.

The total global spend on wheat breeding and research is currently one-quarter of that spent to improve maize.

Researchers plan to use the cash to explore, for example, how to improve the way wheat photosynthesizes. Wheat, frankly, does it badly; it converts just 1% of incoming light to grain. Maize is three times more efficient; sugar cane eight times.

The map of the wheat genome remains a job half-finished. An estimated US\$50 million is needed to map the remaining 20 of wheat’s 42 chromosomes. Obtaining the complete genome should accelerate the effort to make wheat more tolerant to heat and drought through both conventional breeding and genetic-modification techniques.

Crucial work to monitor the spread of wheat pathogens must continue. Borlaug championed this research through the Durable Rust Resistance in Wheat project led by Cornell University in Ithaca, New York, and the Borlaug Global Rust Initiative, a consortium of more than 20 institutions, which has its secretariat at Cornell. Famously, he said that “rust never sleeps”, and the continued spread of the devastating Ug99 stem-rust fungus in Africa and other new strains in Ethiopia (see page 404) demonstrate the truth of his words.

Today, yield is not the only impact by which agriculture is judged. The Intergovernmental Panel on Climate Change will next week report on farming’s direct and indirect consequences for the planet. The focus on the carbon footprint of food production is necessary, but the message cannot be boiled down to the misleading idea that all agricultural techniques bar organic farming are a plague on the environment.

Borlaug believed that increasing yields through the use of new and improved varieties, along with the responsible application of fertilizer and pesticides, could benefit natural ecosystems. Less land would need to be converted into agricultural production to grow food. Recent studies suggest that he was right (J. R. Stevenson et al. Proc. Natl Acad. Sci. USA 110, 8363–8368; 2013).

Misguided opposition to some aspects of big agriculture, such as chemical-fertilizer use in the developing world, could stop many nations from growing the food they need. Objections should be saved for the irresponsible overuse of fertilizer in the West and Asia, which has led to widespread water and air pollution.

One of Borlaug’s guiding principles was that food is the moral right of all who are born into this world. He won an important battle against hunger, but the war continues.


text:
#### xaktly | Algebra | Functions

Polynomial functions
{graphing}

This section focuses on sketching graphs of polynomial functions,

$$f(x) = Ax^n + Bx^{n-1} + \dots + Cx^2 + Dx + E$$

Learn the details on the polynomial functions page.

#### Practical advice on how to sketch the graphs of polynomial functions

In this section we'll focus on how to sketch the graph of any polynomial function, a really important skill. Anybody can plot a function on a computer, but you'll need to know what you're doing to see if the computer has done what you think you asked it to.

We'll outline a few key steps for graphing polynomials below.

At the end of this section is a brief bit about how calculus can help in sketching polynomial graphs. You don't need calculus at all to work through the examples before that section. When you learn calculus, you'll see that it can be very helpful in visualizing the shapes and figuring out the details of graphs of all kinds.

#### Why do I need to learn to graph functions by hand?

Well, nobody's really asking you to be able to plot an extremely accurate graph, point-by-point, by hand. That's one thing that computers are very good at, and ought to be used for. But everyone, from time-to-time, makes an input mistake when plotting a graph on a computer, and we need to be able to recognize when a mistake was made. The computer-plotted graph should be a nice refinement of the sketch you already have on paper or in your head.

### Steps for sketching polynomial graphs

1.

#### Find the roots if you can

Roots, or zeros, of a functions are the points where f(x) = 0. They are found by setting the function equal to zero and solving for x. Not all functions have real roots. Some have imaginary roots, which come in pairs of complex conjugates (a ± ib). Imaginary roots can't be graphed on a real plane, so they're not of much help in sketching a graph.

Remember that you have many methods of finding roots of polynomials at your disposal. You can freshen your memory here.

2.

#### Determine the behavior of the ends

The end behavior of a polynomial graph – what the function does as x → ±∞ – is determined by two things:

• The sign of the coefficient of the leading term, and
• whether the power of the leading term is even or odd.

We'll review that below.

3.

#### Find easy points

Often, there are points on the graph of a polynomial function that are just too easy not to calculate. One is the y-intercept, or f(0). These can help you get the details of a graph correct.

### Roots and turning points

#### Roots

The fundamental theorem of algebra tells us that

Every polynomial function of degree n has n complex roots. Some may be real, and any imaginary roots come in pairs of complex conjugates.

#### Turning points

Every polynomial function of degree n has at most n - 1 turning points. These are also points at which a local maximum or minimum exist, and where the slope of the curve changes from positive-to-negative or vice-versa. A cubic function, for example, may have two turning points, but it also may have none. Turning points can be "smeared out" in any polynomial.

The red cubic curve has two turning points and three real roots. The black curve has no turning points (the slope is positive over the whole domain) and one real root. We'd expect the other two roots to be a pair of complex conjugates, a ± ib.

### Single, double and triple roots

The fully-factored function

$$f(x) = x^3 (x - 2)(x + 4)^2 = 0$$

has three different kinds of roots (not all functions have all kinds; I just made this one up like that so we can look at them all). Let's look at them one at a time.

The x3 term is a triple root at x = 0. Think of it as x·x·x = 0, and that if either of the three x's are zero, then the whole function has a zero value. A triple root at x = 0 means that there is an inflection point there, a point where the curvature of the function changes between concave-upward and concave-downward. It's possible to have an inflection point not located at zero. The factor (x-3)2, for example, indicates an inflection point at x = 3.

The binomial (x + 4) is squared. This is a double root, which means that the graph of this function just touches the x-axis at x = -4. That point might be a minimum or a maximum. We'll figure that out from the end behavior and by plotting selected points later.

The binomial (x - 2) is a single root. The exponent of this binomial is one. The function graph passes through x = 2.

In the previous section we discussed several ways of finding the roots of polynomial functions. Make sure you're an expert at those.

### End behavior

When the independent variable increases in size in either direction ( ± ), the ends of a polynomial graph will eventially increase or decrease without bound (infinitely). In the previous section we showed that the end behavior depends on the sign of the leading coefficient and on the degree of the polynomial. The results are summarized in the table below.

End behavior is a clue about the shape of a polynomial graph that you just can't do without, so you should either memorize these possibilities or (better yet) understand where they come from.

The table below also shows that a polynomial function of degree n can have at most n - 1 points where it changes direction from down-going to up-going.

Here are examples of each of the kinds of end behavior.

### Example 1

Sketch the graph of   $f(x) = x^3 - x^2 - 6x$.

We can easily factor f(x) by first removing a common factor (x) to get

$$f(x) = x(x^2 - x - 6),$$

and then recognizing that we can factor the quadratic by eye to get

$$f(x) = x(x - 3)(x + 2)$$

If we set that equal to zero, our roots are x = 0, x = 3 and x = -2. Notice that all three roots are single roots, so the function graph has to pass right through the x-axis at those points (and no others). This function doesn't have an inflection point on the x-axis (it may have one or more elsewhere, but we won't be able to find those until we can use calculus). And finally, f(x) doesn't have any points where it just touches the axis and "bounces off" – there are no double roots.

The end behavior is down on the left and up on the right, consistent with an odd-degree polynomial with a positive leading coefficient.

Finally, f(0) is easy to calculate, f(0) = 0. With this information, it's possible to sketch a graph of the function.

Start by sketching the axes, the roots and the y-intercept, then add the end behavior:

Finally, just complete the smooth curve the only way the evidence will allow you to do so. Often you'll find that there's no other way but one to complete the path of a function between two points, such as two roots. That's true on the left side (x < 0) of the graph in the next figure. The downward left-end behavior combined with the left and center roots forces the function to bump upward.

It takes a few tries to get the hang of this kind of curve sketching, but it will develop with practice. Notice that there's really no other option for the segment of f(x) between -2 and 0. The curve has to smoothly pass right through both points on the x-axis and go to -∞ on the left.

Likewise there are no other options, given the right-end behavior, for the part of f(x) between 0 and 3.

What we don't know from such a sketch is just exactly how high the maxima rise and how low the minima dive. That will be a job for calculus much later on, or for a computer.

Here is a plot of f(x) made with Mathematica. You can see that it has all of the essential features of our sketch, but that the details are filled in. Because we've already sketched the graph, we can be confident that the computer output is reliable.

### Example 2

Sketch the graph of   $f(x) = x^4 - 4x^3 - 5x^2 + 36x - 36.$

You could find the factorization of this function using the rational root theorem, and you'd get

$$f(x) = (x - 2)^2 (x + 3)(x - 3)$$

Notice that x = 2 is a double root, and x = ±3 are single roots. The ends of this function both go in the same direction because its degree is even, and that direction is upward because the coefficient of the leading term, x4, is positive.

The y-intercept is easy to find from the original form of the function; it's -36. That's enough information to sketch the function. Here it is in one sketch with some explanations, but the process goes like this: Draw in the roots, then the end behavior. Note that the root at x = 2 is one where the function just bounces off the axis. The rest is relatively easy. Except for the fine detail, there's only one way to draw it.

Below is a version of that function plotted with Mathematica. You can see that all of the essential features of our sketch were correct; we just have to blow up the region in green to see the other 3 roots (1 double, 1 single). Graphs are often like this. You should become very accustomed to rescaling – changing the "window" on your calculator, for example – to see features that are relatively small compared to the rest.

### Example 3

Sketch the graph of $f(x) = -(x-2)^3$

The key to sketching a function like this quickly is seeing that it's just the parent function of all cubic functions, y = x3, shifted to the right by 2 units and inverted across the x-axis.

Never forget how function transformations affect any function. They work the same way every time, and knowing how they affect a known function will really help you visualize the transformed function.

For these kinds of graphs, I like to lightly sketch in the parent function, then apply the transformations one at a time. Here is y = x3 and y = (x - 2)3. Here is the parent function (black) shifted two units to the right:

... and here is the final transformation, superimposed upon the other graphs. The -1 on the outside of the function "flips" or reflects it across the x-axis.

The message here is an important one: We don't always need to find roots, intercepts, etc. If we can identify the function as just a series of transformations of some parent function that we know, the graph is pretty easy to visualize. Just take it in steps.

The root at x = 2 is a triple-root, which, for a polynomial function, indicates a an inflection point, a point where the curvature of the graph changes from concave-upward to the left of x = 2 to concave-downward on the right. Polynomial graphs are full of inflection points, but not all are indicated by triple roots. Calculus will help you find those.

### Practice problems

Sketch graphs of these polynomial functions. Peek at the solutions if you need a hint, then compare your graph to a computer-generated graph of the function.

 1 $f(x) = 2x^3 - 8x^2 - 10x$ Solution First divide everything by 2x (the GCF) and find the roots by factoring (because we can): \begin{align} 2x(x^2 -4x + 5) &= 0 \\[5pt] 2x(x - 5)(x + 1) &= 0 \\[5pt] x &= -1, \, 0, \, 5 \end{align} This is a cubic function with a positive leading coefficient, so the ends will look like ↙   ↗ We've already found the y-intercept, f(0), because it's a root, so no extra information there. That should still be enough to sketch the graph. The information we've got about this graph doesn't tell us about the precise locations of the local maximum and minimum (both starred) of this graph, so don't worry about getting those exactly right in your sketch. 2 $f(x) = x^3 - 3x^2 - 28x$ Solution First divide everything by x (the GCF) and find the roots by factoring (because we can): \begin{align} x(x^2 - 3x - 28) &= 0 \\[5pt] x(x - 7)(x + 4) &= 0 \\[5pt] x &= -4, \, 0, \, 7 \end{align} This is a cubic function with a positive leading coefficient, so the ends will look like ↙   ↗ We've already found the y-intercept, f(0), because it's a root, so no extra information there. That should still be enough to sketch the graph. The information we've got about this graph doesn't tell us about the precise (*) locations of the local maximum and minimum of this graph, so don't worry about getting those exactly right in your sketch. Calculus helps with that, by the way. 3 $f(x) = x^3 + x^2 - 10x - 10$ Solution We can find the roots of this function by grouping the first two and last two terms, like this: \begin{align} x^3 + x^2 - 10x - 10 &= 0 \\[5pt] x^2(x + 1) - 10(x + 1) &= 0 \\[5pt] (x + 1)(x^2 - 10) &= 0 \\[5pt] x &= -1, \, ±\sqrt{10} \end{align} The y-intercept is $f(0) = -10.$ The end behavior is ↙   ↗, which puts us in good position to sketch the graph. Here again, you don't have any information about te precise locations of the maxima and minima ("extrema"), but you can still get a pretty good idea of how the graph will look. 4 $f(x) = x^3 + 5x^2 - x - 5$ Solution We can find the roots of this function by grouping the first and third, and second and fourth terms, like this: \begin{align} x^3 + 5x^2 - x - 5 &= 0 \\[5pt] x(x^2 - 1) + 5(x^2 - 1) &= 0 \\[5pt] (x^2 - 1)(x + 5) &= 0 \\[5pt] x &= ±1, \, -5 \end{align} The y-intercept is $f(0) = -5.$ The end behavior is ↙   ↗, which is enough information to sketch the graph. 5 $f(x) = x^3 + x^2 - 14x - 24$   (given that -4 is a root) Solution Given that 4 is a root, we can use synthetic substitution to partially factor the polynomial. We'll set it equal to zero to find the roots: \begin{align} (x - 4)(x^2 + 5x + 6) &= 0 \\[5pt] (x - 4)(x + 2)(x + 3) &= 0 \\[5pt] x &= -3, -2, 4 \end{align} The y-intercept is y = -24 and the end behavior is ↙   ↗. 6 $f(x) = 2x^3 + 14x^2 - 4x - 28$ Solution This function can be factored by grouping like this: \begin{align} 2x^3 + 14x^2 - 4x - 28 &= 0 \\[5pt] 2x(x^2 - 2) + 14(x^2 - 2) &= 0 \\[5pt] (x^2 - 2)(2x + 14) &= 0 \\[5pt] x &= ±\sqrt{2}, \, -7 \end{align} The y-intercept is y = -28, and the end behavior is ↙   ↗. 7 $f(x) = 2x^4 - 8x^2 + 8$ Solution This function has the form of a quadratic, so we can solve it by factoring like this: \begin{align} 2x^4 - 8x^2 + 8 &= 0 \\[5pt] 2(x^4 - 4x^2 + 4) &= 0 \\[5pt] 2(x^2 - 2)(x^2 - 2) &= 0 \\[5pt] x &= ± \sqrt{2} \end{align} There are two double roots here, x = ± 1.414, so we expect to the graph to "bounce" off of the x-axis at those points. The y-intercept is y = 8, and the end behavior of this quartic function with a positive leading coefficient is ↖   ↗. The graph looks like this: 8 $f(x) = 3x^4 - 34x^2 + 63$ Solution This function has the form of a quadratic, so we can solve it by factoring like this: \begin{align} 3x^4 - 34x^2 + 63 &= 0 \\[5pt] (3x^2 - 7)(x^2 - 9) &= 0 \\[5pt] x &= ± \sqrt{\frac{7}{2}}, ±3 \\[5pt] \sqrt{\frac{7}{2}} &\approx ±1.87 \end{align} The y-intercept is y = 63, and the end behavior of this quartic function with a positive leading coefficient is ↖   ↗. 9 $f(x) = -x^4 + 20x^2 - 64$ Solution This function has the form of a quadratic, so we can solve it by factoring like this: \begin{align} -x^4 + 20x^2 - 64 &= 0 \\[5pt] -(x^4 - 20x^2 + 64) &= 0 \\[5pt] -(x^2 - 16)(x^2 - 4) &= 0 \\[5pt] x &= ± 4, \, ± 2 \end{align} The y-intercept is y = -64, and the end behavior of this quartic function with a negative leading coefficient is ↙   ↘. 10 $f(x) = x^4 - 4x^3 - 7x^2 + 34x - 24$   (given that x = 1 and x = 2 are roots.) Solution Using our two known roots, we can partially factor, then completely factor the function: So far the function can be replaced by $$f(x) = (x - 1)(x^3 - 3x^2 - 10x + 24)$$ Now the function is \begin{align} (x - 1)(x - 2)(x^2 - x - 12) &= 0 \\[5pt] (x - 1)(x - 2)(x - 4)(x + 3) &= 0 \\[5pt] x = 1, 2, 4, &-3 \end{align} The y-intercept is y = 24, and the end behavior is ↖   ↗. Here is the graph.

### Where calculus can help

The derivative is the slope of a curve. That slope has a value of zero at maxima and minima of a function, where the slope changes from positive to negative, or vice-versa, so we can find the derivative, set it equal to zero and solve for locations of maxima and minima. This can be very handy in situations where we can't find rational roots or where there are no (or relatively few) real roots. Here's an example of a function without rational roots:

$$f(x) = x^3 - 4x^2 + 14x - 24$$

This is a difficult function to graph because we don't know the roots, but we can find the derivative:

$$f'(x) = 3x^2 - 8x + 14$$

Setting this quadratic function to zero and completing the square gives us these roots:

$$x = \frac{8 ± i \sqrt{26}}{3}$$

Now both of these roots are imaginary, which means our graph has no maxima or minima. That might be boring, but it is good information to have. We can go further by setting the second derivative equal to zero and finding potential inflection points:

$$f''(x) = 6x - 8 = 0 \\[5pt] x = \frac{4}{3}$$

So there is an inflection point at $x = \frac{4}{3}.$ The function value there is about y = -10, and the y-intercept is y = -24, so we can make a quick sketch of this cubic function like this:

So especially when we have scant information about a function otherwise, calculus can be a big help in visualizing a function graph.

xaktly.com by Dr. Jeff Cruzan is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. © 2012-2019, Jeff Cruzan. All text and images on this website not specifically attributed to another source were created by me and I reserve all rights as to their use. Any opinions expressed on this website are entirely mine, and do not necessarily reflect the views of any of my employers. Please feel free to send any questions or comments to jeff.cruzan@verizon.net.


text:
SMeznaric
Reputation
Top tag
Next privilege 125 Rep.
Vote down
 Jun 15 comment r predict glm score based on only partial records This doesn't make any sense. You should replace $x_2$ with $\bar{x}_2$. Mean is the probabilistically weighted estimate of $x_2$. But since you actually have a generalized linear model, you really need to do the following. Suppose your prediction function is $f(x_1, x_2, \ldots, x_n)$. Then the correct prediction with missing values $x_{n_1}, x_{n_2},\ldots x_{n_k}$ is $\int \ldots \int f(x_1, x_2, \ldots, x_n) p(x_{n_1}, \ldots , x_{n_k}) dx_{n_1}\ldots dx{n_k}$, where $p$ is the probability density. Replace integral with sum and density with probability for discrete outcomes. Jul 10 comment Google Apps Script suddenly started throwing 'invalid mime type' errors I have the same problem... Mar 2 awarded Supporter Jul 5 awarded Student May 16 awarded Tumbleweed May 10 revised Checking out an svn copy leads to “working copy locked” edited tags May 9 awarded Editor May 9 revised Checking out an svn copy leads to “working copy locked” added 142 characters in body May 9 asked Checking out an svn copy leads to “working copy locked”


text:
## Precalculus (6th Edition) Blitzer

$(-3,-2)$, $(-3,2)$,$(3,-2)$, $(3,2)$
Here, we have $(x^2+y^2)+(x^2-y^2)=13+5$ Now, $x^2+y^2+x^2-y^2=18$ This gives: $2x^2=18$ This yields : $x^2=9 \implies x=3,-3$ when $x=3$ then we have $9+y^2=13 \implies y^2=4$ and $y=2,-2$ when $x=-3$ then we have $(-3)^2+y^2=13 \implies y^2=4$ and $y=2,-2$ Hence, our answers are: $(-3,-2)$, $(-3,2)$,$(3,-2)$, $(3,2)$


text:
1. ## max

II'm not getting the first part right. If someone can show me, that'd be great. I don't understand the second part at all.

Consider the function below.
(a) Find the maximum value.

(b) Find the value of x at which f increases most rapidly.

2. To find the max of a function you need to find all the critical points (points where the derivative is equal to zero or undefined). You then evaluate these points with the second derivative test( f'' < 0 then the point is a max). For the second part you need to maximise the derivative.


text:
What does Penrose mean when he talks about topology of spacetime?

Let us now set aside the question of the submicroscopic structure of space-time and concentrate, instead, on its large-scale properties. In this case, we may imagine that the smooth manifold picture will be adequate and that its structure in the large can be obtained by piecing together smaller "locally Euclidean" patches, in the manner of overlapping coordinate neighborhoods of differential Geometry. Thus we might arrive at a topology for space-time, in the large, different from a Euclidean topology. Unfortunately too little is known about the large-scale structure of the universe to enable us to make any statement with confidence concerning its global topology (apart, perhaps, from certain statements about its orientability). Thus, it might be that the topology of space-time on a large scale is not at all interesting.

Battelle Recontres, Sir Roger Penrose, page-123.

Could it be explained what exactly Penrose means when he says the topology of space-time? How can one picture it? I am assuming when he says Euclidean topology, he is talking about the metric ball topology in $$\mathbb{R^4}$$.

Instead, what people mean are answers to questions like "Does this space have holes?" (homology), "Does this space have non-trivial loops?" (fundamental group), "Can you embed this space faithfully in $$n$$ dimensions?", i.e. properties of the space that are not "local", that you cannot see if you only look at infinitesimal neighbourhoods of points or a single coordinate chart, but that concern the full space.
• @Aplateofmomos Just that every coordinate patch has the topology of $\mathbb{R}^n$. May 22 at 21:26


text:
## Quark nuggets search using 2350 Kg gravitational waves aluminum bar detectors    [PDF]

P. Astone, M. Bassan, E. Coccia, S. D'Antonio, V. Fafone, G. Giordano, A. Marini, Y. Minenkov, I. Modena, A. Moleti, G. V. Pallottino, G. Pizzella, A. Rocchi, F. Ronga, M. Visco
The gravitational wave resonant detectors can be used as detectors of quark nuggets, like nuclearites (nuclear matter with a strange quark). This search has been carried out using data from two 2350 Kg, 2 K cooled, aluminum bar detectors: NAUTILUS, located in Frascati (Italy), and EXPLORER, that was located in CERN Geneva (CH). Both antennas are equipped with cosmic ray shower detectors: signals in the bar due to showers are continuously detected and used to characterize the antenna performances. The bar excitation mechanism is based on the so called thermo-acoustic effect, studied on dedicated experiments that use particle beams. This mechanism predicts that vibrations of bars are induced by the heat deposited in the bar from the particle. The geometrical acceptance of the bar detectors is 19.5 $\rm m^2$ sr, that is smaller than that of other detectors used for similar searches. However, the detection mechanism is completely different and is more straightforward than in other detectors. We will show the results of ten years of data from NAUTILUS (2003-2012) and 7 years from EXPLORER (2003-2009). The experimental limits we obtain are of interest because, for nuclearites of mass less than $10^{-4}$ grams, we find a flux smaller than that one predicted considering nuclearites as dark matter candidates.
View original: http://arxiv.org/abs/1306.5164


text:
# [381/441] Stream of consciousness 82

Despite the frustration that I have had recently toward my future and my research in trying to finish up my degree, I have mainly stayed sane in terms of not compromising my sleep schedule.  Indeed, the z-noughts (nights of less-than-usual sleep) have been zero since I started going into Hyper Mode.  I fear the effect on my Grogginess if I were to pull an all nighter.

Instead, I have managed to cut back on some of my other unproductivity during the workdays, such as checking Facebook or blogs, which often dogged me previously.  Let me shift to something else, even though this may seem completely unrelated.  Play along with it, and hopefully the whole post doesn’t become obfuscated…

I’ll start noticing a lot more Greek letters in the classes that I teach, not just because of using Greek letters in my mathematical work anyway.  Instead, I am likely to see some “Thetas,” “Kappas,” and “Phi-Deltas,” among others.  At Northwestern, the fraternities and sororities do their recruitment at the beginning of Winter Quarter.  Thus, all the pledges / recruits / whatever they’re called may start showing up with pins and other insignia.

I do not claim to know much about the Greek culture, but I do know that lack of sleep that I mentioned earlier can cause problems with people’s academic performance.  This can be thought of as an extensible pole in the head that blocks off different areas, depending on its angle.

Furthermore, if $|g(z_0)|=1$ for some $z_0$ such that $|z_0|<1$, then by the Maximum Modulus Theorem,  $g$ would be a constant (of modulus 1), and $f(z)=e^{i\theta}z$.

Translation in respect to my argument: I fear that if I pull an all-nighter, which would raise my relative Grogginess to 1, then my Grogginess may become a constant, since my original number of z-naughts (i.e. all-nighters) was zero.  Talk about a Maximum Modulus of fearmongering on my brain!

In case you wonder about the weirdness of this post, the boldfaced sentence is from the Daily Prompt: Page 82 of the book Complex Analysis by Bak and Newman.  In some sense, it also describes my scatterbrained approach right now.  This sometimes happens when I am frazzled, that I start talking in incoherent sentences.  But, because a math book was the closest book when I wrote this post, I had a feeling that this post would turn into weird-prov!

===========================================

Today is the three-hundred and eighty-first day of Mission 441.  Sixty days remain.