text:
# Viotar/Quantifying the signal

(Difference between revisions)
 Revision as of 14:40, 25 January 2011 (view source)S070790 (Talk | contribs)← Older edit Revision as of 14:20, 26 January 2011 (view source)S070790 (Talk | contribs) Newer edit → Line 40: Line 40: |width="2%" style="background-color:#FEF5DE;"| |width="2%" style="background-color:#FEF5DE;"| - |width="49%" style="border:2px solid #fabd23;"| + |width="49%" style="border:2px solid #fabd23;text-align: justify;"|

'''Overview:''' '''Overview:'''

# Software design - Quantifying the signal

William Schattevoet
David Duwaer
Eric Backx
Arjan de Visser

# Overview:

The signal that we want from the string, somehow will have to be read out by the instrument. No matter how this is done, some sensor will provide a signal, in which the vibration we want from the string should be recognised. This recognising has to be done on a reliable, quantitative basis. More specifically, there has to be some kind of scalar quantity (which we'll define as the tonal quality Q) that gives us how far we really are from the ideal trajectory in the bow speed-force space, so a feedback loop can be made to let the system find this trajectory for itself. For this, an experiment will be done, and it's results will be analysed thoroughly.

## Software Design (Quantifying the signal we want to see)

With software design, we mean the way the controller is structured. There are many possibilities, but it is important to design the controller in such a way that it matches the requirements that are stated. The controller will be tested on a fixed point model of the string, so it is also important to verify that the model is accurate enough to represent the real string. Besides that, also the following questions need to be answered to come to a good software design:

• Where does the "pleasant" sound come from that you hear when you stand next to the instrument when it's bowed? Is it mainly the vibration of the body that you hear? In that case it would origin mainly from the pressure variances of the string on the bridge, which translate into the body. On the other hand, it could be mainly the vibration of the string that you hear. In that case, the transversal wave as described by the computer model and measured by a laser sensor is dominant. The outcome of this will be important in the choice of what the capture and amplify exactly, when the instrument is done.
• What do the following vibrations look like for different types of measuring instruments?
• The "pleasant" vibration we want (Helmholtz)
• Raucous noise (bow pressed too hard against the string)
• Surface sound (bow pressed too softly against the string)
• How can we recognize a pleasant (Helmholtz) vibration in time and/or frequency domain?
• What kind of controller do we need to meet all of our requirements?

In order to answer these questions, some experiments have been done. These experiments give information about what a bowed string looks like in both time and frequency domain. When we are able to find out how to recognize a pleasant (Helmholtz) sound from time and/or frequency information, this is a first step in designing an appropriate controller.

### Experiment

To measure Helmholtz motion, a measurement will be done for the A-string and the B-string, on the open string and the 1st, 12th and 13th fret. The open string and 1st fret measurements are needed to "shift" the signal in the frequency domain, when necessary. Everything that shifts up according to the fret change is part of the vibration we want to measure, the rest is noise. With this principle we are hoping to be able to cancel the noise from the measurements. The 12th and 13th fret are done so that the same can be done for a much higher position (one octave up), because the waveform may have a different character there.

To measure raucous noise and surface sound, only the open A- and B-string will be measured. That is, beacause we only want to know what these signals look like and we do not actually use them.

#### Experiment goal

The goal of this experiment is to find out what a Helmholtz vibration and a noisy (surface or raucous) sound look like in frequency and time domain. We measure the vibration of the string in three ways. Firstly, we measure the transversal motion of the string, using a laser. This will be done because we need to know the vibration of the string at one single point, since the model also describes one point. Also the sound that you hear when the instrument is bowed is measured using a microphone. At last, the vibration at the bridge will be measured, using the existing piëzo’s. This is done because of two reasons. Firstly, we want to know the difference between the vibration of the end of the string and the vibration at a single point somewhere in the middle of it. The second reason is that the piëzo’s seem to be the best way to pick up the signal for the controller because these piëzo’s are also used as pick up element in normal electric guitars. The main goal of these measurements is that we want to know how to recognize a clear Helmholtz vibration in the frequency domain. Also the time domain information will be important, but the results for a clear Helmholtz vibration are pretty obvious here.

#### Experiment setup

The measurement with the laser will be done using a Laboratory Interface. For the measurements with the piëzo’s and the microphone, we will use a SigLab. The experiments will be done for two different strings, the A and B string. The string will be bowed at 4 different fret positions, being the open string, the 1st, 12th and 13th fret. All the measurements will be done twice to reduce errors.

#### Results

In figure 1 both the time and frequency domain results are given for what is called a raucous sound, which means that the string is sticking to much. This measurement is done using a piëzo guitar pickup. As can be seen from the power spectrum, there are no harmonic vibrations in this sound. It is all very chaotic and there is only noise. In figure 2 the results are given for what is called a surface sound, which means that the bow force is to low and the bow scratches along the string. In this figure there are some peaks that are clearly higher than others. These are the hormonic frequencies for a Helmholtz vibration as we will see later. Beside those peaks however, there is also a lot of noise in between them. This noise could be a thing that makes a surface sound recognisable later on.

Figure 1: The measurement results for a raucous sound
Figure 2: The measurement results for a surface sound

In figures 3, 4 and 5, the results are given for helmholtz vibration, measured with the microphone, the laser and the piëzo. As can be seen in these figures, a Helmholtz vibration gives clear harmonic peaks in the power spectrum. Especially the measurements done with the piëzo and the laser give a good result. Important to notice when the vibration is measured with the piëzo, is the peak at 50 Hz which is caused by the power supply. Beside that peak however, all the peaks appear in harmonic frequencies. When the result is compared to the result of the surface sound, it is clear to see that there is a lot less noise in a Helmholtz vibration. This may be very important in recognizing the type of the vibration and, more imporatant, make the difference between a surface sound and a helmholtz sound visible.

Figure 3: The measurement results for a Helmnholtz sound measured with a microphone
Figure 4: The measurement results for a Helmnholtz sound measured with a laser
Figure 5: The measurement results for a Helmnholtz sound measured with a piëzo

#### Noise cancellation

The first goal was to cancel the noise from the measurements using the pitch shifting method explained in the experiment plan. This has proved to be not as simple as we have thought. The power spectrum of a measurement may be split up in two components: the 'noise' component, which stays the same when a higher note is played, and the 'harmonic' component, which shifts up when a higher note is played. They may be written as pn and ph, respectively, so that p = ph + pn. The two measurements are called '1' and '2', of which '1' will be pitch-shifted towards the pitch of '2'. The shifted measurement is called 's'. will yield these equations:

• p1 = ph,1 + pn,1
• p2 = ph,2 + pn,2
• ps = ph,s + pn,s
• ph,s = ph,2

These are 4 equations with 6 unknowns, so the system can't be solved. Therefore, the measurements of the 1st and 13th frets are dropped, because they are now only excess measurements.

### Controller Design

#### Possible controller architectures

Before we can decide what type of controller would be best for our system, let's take a look at the possible controller architecture. The first type of controller is open loop (feed forward). This means that the controller only sends a signal to actuators without checking whether the desired requirements are achieved or not. The second architecture is a closed loop (feedback) controller. This controller compares a measured value with a pre-defined value and adaptes the system in such a way, untill the measured value equals the pre-defined value. At last, there is a combination of both. In this controller, all the known information is used to send a feed forward signal to bring the system as close as possible to the desired state. The small changes are made using the feedback signal. This controller is generally preferred above the feedback only controller because controlling on the feedback signal is mostly rather slow.

Reflected on our viotar, this gives the following concepts:

• Feed forward:

All the values for bow speed and force are pre-defined in a look-up table for every fret. From the obtained signal, the fundamental frequency of the vibration can be determined, which is directly related to the played fret. After that, the controller looks up the right values for bow speed and force and uses it as controlvalues.

• Feedback:

The obtained signal is compared with an ideal Helmholtz signal, and a “tone quality” is assigned. Using this rating as a feedback quantity, a closed loop is created with the goal to get an ideal Helmholtz signal from the string.

• Feed forward and feedback:

First, the right bow force and speed are determined using the lookup table, and actuated. Then, the comparison with the ideal Helmholtz signal starts, creating a feedback loop using this “tone quality”. This feedback signal is only used for fine-tuning the bow force and speed.

A combination of feed forward and feedback theoretically leads to the best result. That's why we choose to work this concept out first. In theory this means that tone intensity and quality will be controlled in the way shown in figure 6. In order to do that, we need to be able to recognize Helmholtz and quantify the signal. This can be done in both time and frequency domain as we will see later.

Figure 6: Quality and intensity paths

#### Recognising Helmholtz and quantifying the signal

Probably, Helmholtz is the only harmonic vibration that you can get from a string when you bow it. With a bow you can never get a normal standing wave as when you would pluck the string. Because of this, it is not necessary to quantify "how much" the measured vibration is the specific Helmholtz waveform. It may suffit to merely quantify how harmonic the measured vibration is. This can be done by detecting the fundamental frequency in the fft of the signal, and looking how many multiplications of this frequency are still in the signal. The more overtones, the sharper the Helmholtz, and therefore the better the tone.

In order to do this we made amplitude plots in the frequency domain. This gives information about the frequencies at which high peaks appear and what their amplitudes are. We did this for the model as well as for our measurements. When we first analyzed the model, we seemed to be right in the fact that as the tone gets better, more peaks appear in the fft spectrum. These peaks are not randomly spread out, but appear at harmonic frequencies. That is, at n-times the fundamental frequency with n being the number of the peak. This is also made visible in the figures below. These figures show the difference between the frequency that you would expect following this rule and the actual frequency that comes out of the model. For an unidentifiable tone, there are no harmonic tones on the expected frequencies, as the graph runs out of the figure. For a clear Helmholtz vibration however, the rule is satisfied for nine peaks. A second thing that becomes clear by analyzing the results from the model, is that the amplitude of every next peak decreases exponentially.

Figure 7: Amplitude ratio and frequency errors for an unidentifiable sound
Figure 8: Amplitude ratio and frequency errors for a Helmholtz vibration

When we take a look at the measurements results, it becomes clear that these measurements are not as “clean” as the model. The same figures as for the model are also made for the measurements, as you can see below. The amplitude of the peaks does indeed decrease more or less exponentially as we would expect from the model. The number of peaks that appear at the expected frequency however, is only three for a vibration that sounded like a clear Helmholtz vibration to us. This can be explained by the fact that these measurements are done using a piezo element and the string vibrates along this element instead of perpendicular to it, which gives another signal. This problem is going to be solved however, because in the meantime experiments have proofed that the signal gets better when the string vibrates perpendicular, like it will on our prototype.

Figure 9: Amplitude ratio and frequency errors for measured Helmholtz sound

So, we seemed to be right in the fact that a vibration being Helmholtz has something to do with the frequencies at which harmonic peaks appear and the amplitude of that peaks compared to that of the fundamental frequency. There is only one important thing that makes this method of quantifying the signal irrelevant for our prototype control system. The point is that for this method a fourier transformation needs to be done in the control unit in order to detect what the quality of the signal is. The problem is, that a fourier transformation cannot be done instantaneously but only when enough information about the vibration is gathered. A simple rule tells that the resolution of the fft equals 1/(sample time). In our case, where quality of the sound depends strongly on the exact frequencies where peaks appear, we should have a resolution in the frequency domain of at least 1 Hz. This means that the sample time for every fft needs to be about a second, while the vibration needs to be adapted in several milliseconds up to several hundreds of seconds at most. So, this method is simply never going to satisfy our requirements. However, there is another way to perform this method, being in the time domain. When we take a look at the sawtooth like waveform of a Helmholtz vibration, we can already in the time domain draw some conclusions regarding to the quality of the vibration. The reason for this is that the harmonic peaks in the time domain, with their decreasing amplitudes, and the saw-toothed waveform in the time domain are strongly related to each other. A saw-toothed waveform essentially is a set of harmonic sinuses with decreasing amplitudes, being sharper when more harmonic sinuses are present. Putting this in an equation leads to the following expression for the signal, consisting of n harmonics:

$f=\sum_{i=1}^{n}(1/n) sin(nt)$

So the fact that more harmonic peaks appear in the frequency domain, finds is origin in the fact that more harmonic sinuses occur in the time domain. Moreover, when we want to quantify the signal in the time domain on the same properties as we did in the frequency domain, we only have to assess the signal on its sharpness. To proof this theory, figure 10 shows how the shape of the signal changes as the number of harmonic sinuses is increased. This leads to a perfectly sharp saw tooth, when the number of harmonic sinuses goes to infinity.

Figure 10: Sawtooth signals for an increasing number of harmonics

So, the idea is that we quantify the signal on the sharpness of the sawtooth. In order to do this we adapted our model and added a possibility to generate a sawtooth that serves as a reference. The correlation between the signal and our auto-generated reference sawtooth will be used as the quantification. This method will reduce the sample time to the longest period in the signal, which is 1 devided by the lowest frequency present in the signal. In this case the lowest frequency is about 100 Hz, so the sample time is about 10 milliseconds. To find out whether the signal indeed can be quantified on its sharpness (and thuss number of harmonics), we did some experiments. In the Helmholtz region, we varied the bowing speed at a constant bowing force and varied the bowing force at a constant speed. For all these simulations the correlation is calculated and plotted in the figures below (figures 11 and 12). From these figures, it can easily be concluded that there is not an ideal combination of bowing speed and force. That is, there is not an optimum which gives the best Helmholtz vibration. This means that when the vibration is a so called Helmholtz vibration, the system cannot be controlled to a point at which the correlation is highest. That is why we choose to make a lookup table with combinations of bowing speeds and forces that are in the Helmholtz region. The control unit then only needs to identify the fundamental frequency and lookup the right settings for the bowing speed and force. This gives great advantages regarding to adaptation time, because the controlling time now reduces to one sample time.

Figure 11: Correlation for varying bowing speeds
Figure 12: Correlation for varying bowing forces

#### Controller concept

The process described above, brought us to a controller design for the prototype. This controller makes use of a look-up table. This look-up table contains all the pre-defined values for bowing speed and force. By determining the fundamental frequency of the signal, the controller "knows" which fret is played and therefor what values for bowing speed and force are required. To make sure that the bowing speed indeed equals the value from the look-up table (also under varying bowing force) the engine speed is measured using an encoder and looped back to the controller. For the bowing force this does not seem to be neccesary, since the bowing force does not depend on the bowing speed.


text:
VLA > Green Book

Green Book

last modified Jun 23, 2014

The VLA Green Book

Caution: The VLA Green Book is no longer being maintained and much of the information in it obsolete.We are keeping it accessible for historical reasons only.

When the VLA Green Book was written in 1978 (!), its original purpose was to serve as an introduction to the VLA for prospective observers, providing an overall view of the VLA and information about the instrument at a level appropriate to those who may not know a great deal about interferometry and aperture synthesis techniques. It has been updated sporadically, and the current version was last updated in 1992. Although much of the information is outdated, there will be information of interest. For current information on the status of the array the reader is referred to the VLA web pages.

The Green Book is available for download in postscript format here.

For reasons unknown two useful and popular plots from the Green Book were not included in the scanned version and are therefore made available here:

format: plain


text:
1 Dec 2009 08:21

Hi,

Is it possible to modify the following code (while stepwise
showing a mindmap) such that the left branch got a different
color than the right branch?  I'd like to use the the color
to emphasize the different concepts rather than the different
levels.  So the left branch might be magenta with variable
saturation for the levels and the right branch green, e.g.
The respective chapters in the fine manual are way too
sophisticated for me ...

Regards,

Juergen

\documentclass{beamer}
\usepackage{tikz}
\usetikzlibrary{mindmap,trees}
\begin{document}
\tikzset{%
mindmap/.style={%
level 1/.append style={level 1 concept},
level 2/.append style={level 2 concept},
level 3/.append style={level 3 concept},
concept color=magenta!30,
level 1 concept/.style={%
level distance=5cm,
every child/.style={concept color=green!30},
},
level 2 concept/.style={%
level distance=3cm,
every child/.style={concept color=red!30},
},
level 3 concept/.style={%
level distance=3cm,
every child/.style={concept color=blue!30},
},
every node/.style={concept},
},
visible from/.code={%
\ifnum#1>\overlay%
\tikzset{%
circle connection bar switch color/.code={},
edge from parent/.style={draw=none},
every node/.style={
concept, draw=none, fill=none,
execute at begin node={\setbox0=\hbox\bgroup\hskip0pt\let\\=\relax},
execute at end node=\egroup\phantom{\box0}
}%
}%
\fi%
}
}
\begin{frame}
\frametitle{Mindmap with Beamer}
\begin{tikzpicture}[transform canvas={scale=0.5},remember picture, overlay, mindmap]
\foreach \overlay in {1,...,19}{%
\node<\overlay> at (current page.center) {\shortstack{Modulations-\vphantom{y}\\verfahren}}
child[visible from=2,grow=0] {
node (sinus) {\shortstack{Sinusträger\\\tiny(zeitkontinuierlich)}}
child[visible from=3,grow=90] {
node (sinusk) {\shortstack{wert-\\kontinu-\\ierlich}}
child[visible from=4,grow=30] { node {AM} }
child[visible from=5,grow=90]   { node {FM} }
child[visible from=6,grow=150]  { node {PM} }
}
child[visible from=7,grow=-90] {
node (sinusd) {\shortstack{wert-\\diskret}}
child[visible from=8,grow=-150] { node {ASK} }
child[visible from=9,grow=-90]   { node {FSK} }
child[visible from=10,grow=-30]  { node {PSK} }
}
}
child[visible from=11,grow=180] {
node (puls) {\shortstack{Pulsträger\\\tiny(zeitdiskret)}}
child[visible from=12,grow=90] {
node (pulsk) {\shortstack{wert-\\kontinu-\\ierlich}}
child[visible from=13,grow=30] { node {PAM} }
child[visible from=14,grow=90]   { node {PPM} }
child[visible from=15,grow=150]  { node {PDM} }
}
child[visible from=16,grow=-90] {
node (pulsd) {\shortstack{wert-\\diskret/\\codiert}}
child[visible from=17,grow=-150] { node {PCM} }
child[visible from=18,grow=-90]   { node {DM} }
child[visible from=19,grow=-30]  { node {DPCM} }
}
};
}
\end{tikzpicture}
\end{frame}
\end{document}

------------------------------------------------------------------------------
a free event focused on virtualization and cloud computing.
http://p.sf.net/sfu/redhat-sfdev2dev
_______________________________________________
pgf-users mailing list
pgf-users <at> lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/pgf-users

1 Dec 2009 18:33

Special Graph Paper

Hi,

I am trying to design an experiment in changing bases for my linear
algebra students. Ordinary graph paper is designed on the basis
vectors (1,0) and (0,1). I need to draw graph paper using the basis
vectors (2,1) and (1,2).

I need the grid to cover a full sheet of 8.5in by 11in paper. I need
the origin to be centered in the middle of the page, then I need grid
lines in the direction of (2,1) and grid lines in the direction of
(1,2) to cover the entire page. For example, if I start at the origin,
I first draw a line in the direction of (2,1). Then I move 1 unit
right and 2 units up and draw another grid line in the direction of
(2,1), etc. I do a similar thing, drawing grid lines in the direction
of (1,2).

Can anyone help? Give me some ideas of how I can cover an entire page
with such a grid?

Thanks.

David Arnold
College of the Redwoods

------------------------------------------------------------------------------
a free event focused on virtualization and cloud computing.
http://p.sf.net/sfu/redhat-sfdev2dev

1 Dec 2009 19:53

tikz figure sizes in beamer and latex

I am using tikz for figures in both beamer slides and regular latex. The
difficulty is that a single figure will fit nicely on a text page, but it will
be huge on a beamer slide. Is there an easy way to create the figure once that
will size for both document types?

Thanks

------------------------------------------------------------------------------
a free event focused on virtualization and cloud computing.
http://p.sf.net/sfu/redhat-sfdev2dev

2 Dec 2009 00:01

Re: Special Graph Paper

Hi,

Is it necessary to fill the entire page? You may be able to design your
experiment with a grid aligned to your base and an equally sized grid
aligned to the standard base. I do not know if that meets your purpose, but
you could do that like this:

\documentclass{article}
\usepackage[margin=1cm]{geometry}
\usepackage{tikz}

\begin{document}

\begin{tikzpicture}
\draw[gray!20] (0,0) grid (18,24);

\foreach \y in {0,3,...,21}
\foreach \x in {0, 1.5,..., 16.5}
\draw (\x,\y)--(\x+1.5,\y+3);

\foreach \y in {0,1.5,...,22.5}
\foreach \x in {0, 3,..., 15}
\draw (\x,\y)--(\x+3,\y+1.5);

\fill[black] (9,12) circle (1mm);
\end{tikzpicture}

\end{document}

Regards,
Gerben

dwarnold wrote:
>
> Hi,
>
> I am trying to design an experiment in changing bases for my linear
> algebra students. Ordinary graph paper is designed on the basis
> vectors (1,0) and (0,1). I need to draw graph paper using the basis
> vectors (2,1) and (1,2).
>
> I need the grid to cover a full sheet of 8.5in by 11in paper. I need
> the origin to be centered in the middle of the page, then I need grid
> lines in the direction of (2,1) and grid lines in the direction of
> (1,2) to cover the entire page. For example, if I start at the origin,
> I first draw a line in the direction of (2,1). Then I move 1 unit
> right and 2 units up and draw another grid line in the direction of
> (2,1), etc. I do a similar thing, drawing grid lines in the direction
> of (1,2).
>
> Can anyone help? Give me some ideas of how I can cover an entire page
> with such a grid?
>
> Thanks.
>
> David Arnold
> College of the Redwoods
>
>
> ------------------------------------------------------------------------------
> Join us December 9, 2009 for the Red Hat Virtual Experience,
> a free event focused on virtualization and cloud computing.
> http://p.sf.net/sfu/redhat-sfdev2dev
> _______________________________________________
> pgf-users mailing list
> pgf-users <at> lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/pgf-users
>
>

--

--
View this message in context: http://old.nabble.com/Special-Graph-Paper-tp26594360p26600631.html
Sent from the pgf-users mailing list archive at Nabble.com.

------------------------------------------------------------------------------
a free event focused on virtualization and cloud computing.
http://p.sf.net/sfu/redhat-sfdev2dev

2 Dec 2009 00:54

Re: Special Graph Paper

All,

This is definitely a solution that will work for me. However, I am
still wondering:

Is there a way to:

1. Define nodes at (0,0) and (2,1).

2. Draw a line through the nodes that will definitely extend beyond
the edge of the page.

3. Shift the line (up or down by (1,2)) til the lines leave the page.

4. Repeat for a line through (0,0) and (1,2)

If so, then this could easily be adapted by changing the vectors (2,1)
and (1,2) to, say (1,1) and (-1,1), and get a new sheet of graph paper
based on the new basis.

David

On Dec 1, 2009, at 3:01 PM, GGBBRR wrote:

>
> Hi,
>
> Is it necessary to fill the entire page? You may be able to design
> your
> experiment with a grid aligned to your base and an equally sized grid
> aligned to the standard base. I do not know if that meets your
> purpose, but
> you could do that like this:
>
> \documentclass{article}
> \usepackage[margin=1cm]{geometry}
> \usepackage{tikz}
>
> \begin{document}
>
> \begin{tikzpicture}
> \draw[gray!20] (0,0) grid (18,24);
>
> \foreach \y in {0,3,...,21}
>  \foreach \x in {0, 1.5,..., 16.5}
>    \draw (\x,\y)--(\x+1.5,\y+3);
>
> \foreach \y in {0,1.5,...,22.5}
>  \foreach \x in {0, 3,..., 15}
>    \draw (\x,\y)--(\x+3,\y+1.5);
>
> \fill[black] (9,12) circle (1mm);
> \end{tikzpicture}
>
> \end{document}
>
> Regards,
> Gerben
>
>
>
> dwarnold wrote:
>>
>> Hi,
>>
>> I am trying to design an experiment in changing bases for my linear
>> algebra students. Ordinary graph paper is designed on the basis
>> vectors (1,0) and (0,1). I need to draw graph paper using the basis
>> vectors (2,1) and (1,2).
>>
>> I need the grid to cover a full sheet of 8.5in by 11in paper. I need
>> the origin to be centered in the middle of the page, then I need grid
>> lines in the direction of (2,1) and grid lines in the direction of
>> (1,2) to cover the entire page. For example, if I start at the
>> origin,
>> I first draw a line in the direction of (2,1). Then I move 1 unit
>> right and 2 units up and draw another grid line in the direction of
>> (2,1), etc. I do a similar thing, drawing grid lines in the direction
>> of (1,2).
>>
>> Can anyone help? Give me some ideas of how I can cover an entire page
>> with such a grid?
>>
>> Thanks.
>>
>> David Arnold
>> College of the Redwoods
>>
>>
>> ------------------------------------------------------------------------------
>> Join us December 9, 2009 for the Red Hat Virtual Experience,
>> a free event focused on virtualization and cloud computing.
>> http://p.sf.net/sfu/redhat-sfdev2dev
>> _______________________________________________
>> pgf-users mailing list
>> pgf-users <at> lists.sourceforge.net
>> https://lists.sourceforge.net/lists/listinfo/pgf-users
>>
>>
>
> --
> View this message in context: http://old.nabble.com/Special-Graph-Paper-tp26594360p26600631.html
> Sent from the pgf-users mailing list archive at Nabble.com.
>
>
> ------------------------------------------------------------------------------
> Join us December 9, 2009 for the Red Hat Virtual Experience,
> a free event focused on virtualization and cloud computing.
> http://p.sf.net/sfu/redhat-sfdev2dev
> _______________________________________________
> pgf-users mailing list
> pgf-users <at> lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/pgf-users

------------------------------------------------------------------------------
a free event focused on virtualization and cloud computing.
http://p.sf.net/sfu/redhat-sfdev2dev

2 Dec 2009 05:55

Re: Special Graph Paper

Here is a file that does all of that except that you need to specify how
many lines need to be drawn.  I don't know enough tex to make it do the
division for you.

You need to run pdflatex twice on it so that the page coordinates come
out right.

Hope that helps

--Mike

David Arnold wrote:
> All,
>
> This is definitely a solution that will work for me. However, I am
> still wondering:
>
> Is there a way to:
>
> 1. Define nodes at (0,0) and (2,1).
>
> 2. Draw a line through the nodes that will definitely extend beyond
> the edge of the page.
>
> 3. Shift the line (up or down by (1,2)) til the lines leave the page.
>
> 4. Repeat for a line through (0,0) and (1,2)
>
> If so, then this could easily be adapted by changing the vectors (2,1)
> and (1,2) to, say (1,1) and (-1,1), and get a new sheet of graph paper
> based on the new basis.
>
> David
>
>
> On Dec 1, 2009, at 3:01 PM, GGBBRR wrote:
>
>
>> Hi,
>>
>> Is it necessary to fill the entire page? You may be able to design
>> your
>> experiment with a grid aligned to your base and an equally sized grid
>> aligned to the standard base. I do not know if that meets your
>> purpose, but
>> you could do that like this:
>>
>> \documentclass{article}
>> \usepackage[margin=1cm]{geometry}
>> \usepackage{tikz}
>>
>> \begin{document}
>>
>> \begin{tikzpicture}
>> \draw[gray!20] (0,0) grid (18,24);
>>
>> \foreach \y in {0,3,...,21}
>>  \foreach \x in {0, 1.5,..., 16.5}
>>    \draw (\x,\y)--(\x+1.5,\y+3);
>>
>> \foreach \y in {0,1.5,...,22.5}
>>  \foreach \x in {0, 3,..., 15}
>>    \draw (\x,\y)--(\x+3,\y+1.5);
>>
>> \fill[black] (9,12) circle (1mm);
>> \end{tikzpicture}
>>
>> \end{document}
>>
>> Regards,
>> Gerben
>>
>>
>>
>> dwarnold wrote:
>>
>>> Hi,
>>>
>>> I am trying to design an experiment in changing bases for my linear
>>> algebra students. Ordinary graph paper is designed on the basis
>>> vectors (1,0) and (0,1). I need to draw graph paper using the basis
>>> vectors (2,1) and (1,2).
>>>
>>> I need the grid to cover a full sheet of 8.5in by 11in paper. I need
>>> the origin to be centered in the middle of the page, then I need grid
>>> lines in the direction of (2,1) and grid lines in the direction of
>>> (1,2) to cover the entire page. For example, if I start at the
>>> origin,
>>> I first draw a line in the direction of (2,1). Then I move 1 unit
>>> right and 2 units up and draw another grid line in the direction of
>>> (2,1), etc. I do a similar thing, drawing grid lines in the direction
>>> of (1,2).
>>>
>>> Can anyone help? Give me some ideas of how I can cover an entire page
>>> with such a grid?
>>>
>>> Thanks.
>>>
>>> David Arnold
>>> College of the Redwoods
>>>
>>>
>>> ------------------------------------------------------------------------------
>>> Join us December 9, 2009 for the Red Hat Virtual Experience,
>>> a free event focused on virtualization and cloud computing.
>>> http://p.sf.net/sfu/redhat-sfdev2dev
>>> _______________________________________________
>>> pgf-users mailing list
>>> pgf-users <at> lists.sourceforge.net
>>> https://lists.sourceforge.net/lists/listinfo/pgf-users
>>>
>>>
>>>
>> --
>> View this message in context: http://old.nabble.com/Special-Graph-Paper-tp26594360p26600631.html
>> Sent from the pgf-users mailing list archive at Nabble.com.
>>
>>
>> ------------------------------------------------------------------------------
>> Join us December 9, 2009 for the Red Hat Virtual Experience,
>> a free event focused on virtualization and cloud computing.
>> http://p.sf.net/sfu/redhat-sfdev2dev
>> _______________________________________________
>> pgf-users mailing list
>> pgf-users <at> lists.sourceforge.net
>> https://lists.sourceforge.net/lists/listinfo/pgf-users
>>
>
>
> ------------------------------------------------------------------------------
> Join us December 9, 2009 for the Red Hat Virtual Experience,
> a free event focused on virtualization and cloud computing.
> http://p.sf.net/sfu/redhat-sfdev2dev
> _______________________________________________
> pgf-users mailing list
> pgf-users <at> lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/pgf-users
>

Attachment (grid.latex): text/x-tex, 990 bytes
Attachment (grid.pdf): application/pdf, 2065 bytes
------------------------------------------------------------------------------
a free event focused on virtualization and cloud computing.
http://p.sf.net/sfu/redhat-sfdev2dev
_______________________________________________
pgf-users mailing list
pgf-users <at> lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/pgf-users

2 Dec 2009 07:39

Re: Special Graph Paper

Mike,

This is truly brilliant!

D.

On Dec 1, 2009, at 8:55 PM, Michael George wrote:

> Here is a file that does all of that except that you need to specify
> how many lines need to be drawn.  I don't know enough tex to make it
> do the division for you.
>
> You need to run pdflatex twice on it so that the page coordinates
> come out right.
>
> Hope that helps
>
> --Mike
>
> David Arnold wrote:
>> All,
>>
>> This is definitely a solution that will work for me. However, I am
>> still wondering:
>>
>> Is there a way to:
>>
>> 1. Define nodes at (0,0) and (2,1).
>>
>> 2. Draw a line through the nodes that will definitely extend
>> beyond  the edge of the page.
>>
>> 3. Shift the line (up or down by (1,2)) til the lines leave the page.
>>
>> 4. Repeat for a line through (0,0) and (1,2)
>>
>> If so, then this could easily be adapted by changing the vectors
>> (2,1)  and (1,2) to, say (1,1) and (-1,1), and get a new sheet of
>> graph paper  based on the new basis.
>>
>> David
>>
>>
>> On Dec 1, 2009, at 3:01 PM, GGBBRR wrote:
>>
>>
>>> Hi,
>>>
>>> Is it necessary to fill the entire page? You may be able to
>>> design  your
>>> experiment with a grid aligned to your base and an equally sized
>>> grid
>>> aligned to the standard base. I do not know if that meets your
>>> purpose, but
>>> you could do that like this:
>>>
>>> \documentclass{article}
>>> \usepackage[margin=1cm]{geometry}
>>> \usepackage{tikz}
>>>
>>> \begin{document}
>>>
>>> \begin{tikzpicture}
>>> \draw[gray!20] (0,0) grid (18,24);
>>>
>>> \foreach \y in {0,3,...,21}
>>> \foreach \x in {0, 1.5,..., 16.5}
>>>   \draw (\x,\y)--(\x+1.5,\y+3);
>>>
>>> \foreach \y in {0,1.5,...,22.5}
>>> \foreach \x in {0, 3,..., 15}
>>>   \draw (\x,\y)--(\x+3,\y+1.5);
>>>
>>> \fill[black] (9,12) circle (1mm);
>>> \end{tikzpicture}
>>>
>>> \end{document}
>>>
>>> Regards,
>>> Gerben
>>>
>>>
>>>
>>> dwarnold wrote:
>>>
>>>> Hi,
>>>>
>>>> I am trying to design an experiment in changing bases for my linear
>>>> algebra students. Ordinary graph paper is designed on the basis
>>>> vectors (1,0) and (0,1). I need to draw graph paper using the basis
>>>> vectors (2,1) and (1,2).
>>>>
>>>> I need the grid to cover a full sheet of 8.5in by 11in paper. I
>>>> need
>>>> the origin to be centered in the middle of the page, then I need
>>>> grid
>>>> lines in the direction of (2,1) and grid lines in the direction of
>>>> (1,2) to cover the entire page. For example, if I start at the
>>>> origin,
>>>> I first draw a line in the direction of (2,1). Then I move 1 unit
>>>> right and 2 units up and draw another grid line in the direction of
>>>> (2,1), etc. I do a similar thing, drawing grid lines in the
>>>> direction
>>>> of (1,2).
>>>>
>>>> Can anyone help? Give me some ideas of how I can cover an entire
>>>> page
>>>> with such a grid?
>>>>
>>>> Thanks.
>>>>
>>>> David Arnold
>>>> College of the Redwoods
>>>>
>>>>
>>>> ------------------------------------------------------------------------------
>>>> Join us December 9, 2009 for the Red Hat Virtual Experience,
>>>> a free event focused on virtualization and cloud computing.
>>>> http://p.sf.net/sfu/redhat-sfdev2dev
>>>> _______________________________________________
>>>> pgf-users mailing list
>>>> pgf-users <at> lists.sourceforge.net
>>>> https://lists.sourceforge.net/lists/listinfo/pgf-users
>>>>
>>>>
>>>>
>>> --
>>> View this message in context: http://old.nabble.com/Special-Graph-Paper-tp26594360p26600631.html
>>> Sent from the pgf-users mailing list archive at Nabble.com.
>>>
>>>
>>> ------------------------------------------------------------------------------
>>> Join us December 9, 2009 for the Red Hat Virtual Experience,
>>> a free event focused on virtualization and cloud computing.
>>> http://p.sf.net/sfu/redhat-sfdev2dev
>>> _______________________________________________
>>> pgf-users mailing list
>>> pgf-users <at> lists.sourceforge.net
>>> https://lists.sourceforge.net/lists/listinfo/pgf-users
>>>
>>
>>
>> ------------------------------------------------------------------------------
>> Join us December 9, 2009 for the Red Hat Virtual Experience,
>> a free event focused on virtualization and cloud computing. Attend
>> http://p.sf.net/sfu/redhat-sfdev2dev
>> _______________________________________________
>> pgf-users mailing list
>> pgf-users <at> lists.sourceforge.net
>> https://lists.sourceforge.net/lists/listinfo/pgf-users
>>
>
> \documentclass{article}
>
> \usepackage{tikz}
> \usetikzlibrary{calc}
> \pagestyle{empty}
>
> \begin{document}
>
> %
> % x and y are the basis
> % n is the number of lines in each direction
> %
> \begin{tikzpicture}[remember picture,overlay,x={(1cm,2cm)}, y={(2cm,
> 1cm)}]
> \newcommand{\n}{15}
>
> %
> % the corners of the page
> %
>
> \coordinate (sw) at (current page.south west);
> \coordinate (se) at (current page.south east);
> \coordinate (nw) at (current page.north west);
> \coordinate (ne) at (current page.north east);
>
> \coordinate (origin) at (current page.center);
>
> %
> % loop through and draw the axes
> %
> \foreach \i in {-\n, ..., \n} {
> 	\path (origin) ++(\i,0) coordinate (xa);
> 	\path (origin) ++(\i,1) coordinate (xb);
> 	\path (origin) ++(0,\i) coordinate (ya);
> 	\path (origin) ++(1,\i) coordinate (yb);
>
> 	\draw (intersection of sw--se and xa--xb) -- (intersection of nw--
> ne and xa--xb);
> 	\draw (intersection of sw--se and ya--yb) -- (intersection of nw--
> ne and ya--yb);
> }
>
> \end{tikzpicture}
>
> \newpage
>
> \end{document}
> <grid.pdf>

------------------------------------------------------------------------------
a free event focused on virtualization and cloud computing.
http://p.sf.net/sfu/redhat-sfdev2dev

2 Dec 2009 11:35

Re: tikz figure sizes in beamer and latex

On Tuesday 01 December 2009 19:53:46 Matthew Mah wrote:
> I am using tikz for figures in both beamer slides and regular latex. The
> difficulty is that a single figure will fit nicely on a text page, but it
> will be huge on a beamer slide. Is there an easy way to create the figure
> once that will size for both document types?

You definitely want to do the figure without units, so you only have to change
"scale=0.8" or similar (x=...,y=...) in the tikzpicture's options once.

Furthermore, if you want to put your figure into an external file (e.g. I am
\input'ing .tikz files from more than one document), you might want to specify
the size

a) in relation to \linewidth, e.g. using
\pgfmathsetlength{\imagewidth}{.35\linewidth}%
\pgfmathsetlength{\imagescale}{\imagewidth/45}% pixel width of image
\begin{tikzpicture}[x=\imagescale,y=-\imagescale]
as described on
http://kogs-www.informatik.uni-hamburg.de/~meine/tikz/

or

b) using some predefined macro/length register that you set to the desired
value in your main docs, before the \input.

Actually, I often put additional \pause{} commands / other animation commands
into the figure for the presentation, so I tend to have two files anyway.
Then, I need to merge content changes e.g. using xxdiff.

HTH,
Hans

------------------------------------------------------------------------------
a free event focused on virtualization and cloud computing.
http://p.sf.net/sfu/redhat-sfdev2dev

2 Dec 2009 15:10

Re: pgfpages and rotation

Anyone with an answer for me? The documentation sounded so promising...

Susan

Quoting Susan Dittmar (Susan.Dittmar <at> gmx.de):
> Hello folks,
>
> again I need help. This time with the pgfpages package.  I'm trying to
> combine 8 logical pages onto one physical page.  All is fine until I add
> rotation command -- something must be wrong here. Probably I am using a
> faulty syntax. Unfortunately I did not find any examples using this.
> Does one of you know what I did wrong?
>
>
> 	Susan
>
> %%%%%%%%%%%%%%%%%% test.tex %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
> \documentclass[a4paper,twoside,onecolumn,10pt,pagesize,parskip-]{scrartcl}
> \usepackage[a4paper,portrait,left=5mm,right=5mm,top=5mm,bottom=5mm,
>             heightrounded,nomarginpar]{geometry}
>
> \usepackage{calc}
> \usepackage{pgf}
> \usepackage{pgfpages}
>
> \newlength{\CardWidthI}\setlength{\CardWidthI}{297mm / 8}
> \newlength{\CardHeightI}\setlength{\CardHeightI}{210mm / 4}
> \pgfpagesdeclarelayout{A8 auf A5 fuer Cardkarten}
> {
> %   \def\pgfpageoptionborder{0.4pt}
> }
> {
>     \pgfpagesphysicalpageoptions
>     {%
>         logical pages=1,%
>         physical height=297mm,%
>         physical width=210mm%
>     }
>     \pgfpageslogicalpageoptions{1}
>     {%
>         resized width=\CardWidthI,%
>         resized height=\CardHeightI,%
>         center=\pgfpoint{105mm - .5\CardHeightI}{148.5mm + 1.5\CardWidthI},%
>         rotation=90,%   <----------- comment that out and rest is fine.
>         border code=\pgfstroke,%
>     }%
> }
>
> \pgfpagesuselayout{A8 auf A5 fuer Cardkarten}[a4paper]
>
> \begin{document}
>
> \textbf{\Huge Dies ist Seite 1}\newpage
>
> \end{document}
> %%%%%%%%%%%%%%%%%%%%%%% error message: %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
> ! Missing } inserted.
> <inserted text>
>                 }
> l.37 \end{document}
> %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

> ------------------------------------------------------------------------------
> Let Crystal Reports handle the reporting - Free Crystal Reports 2008 30-Day
> trial. Simplify your report design, integration and deployment - and focus on
> what you do best, core application coding. Discover what's new with
> Crystal Reports now.  http://p.sf.net/sfu/bobj-july
> _______________________________________________
> pgf-users mailing list
> pgf-users <at> lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/pgf-users

------------------------------------------------------------------------------
a free event focused on virtualization and cloud computing.
http://p.sf.net/sfu/redhat-sfdev2dev
_______________________________________________
pgf-users mailing list
pgf-users <at> lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/pgf-users

2 Dec 2009 15:22

Using relative coordinates

Hi all

I am curious if the behavior of the code below is expected. Is perhaps
the use of \foreach in the second construct incorrect? Or is this an
issue in pgf 2.00?

\documentclass{article}
\usepackage{tikz}
\usetikzlibrary{chains,positioning,scopes,matrix}

\begin{document}

\begin{tikzpicture}
% Reference
\path (0,0)
\foreach \s in {0, ..., 3} {
(4mm*\s, 0mm) node (x_\s) {$x_{\s}$}
};

% Relative coordinates w/ update don't seem to work
\path (0,-4mm)
\foreach \s in {0, ..., 3} {
node (s_\s) {$s_{\s}$}  ++(4mm, 0mm)
};

% Doesn't compile. Should it?
%\draw (0,0) to +(0, 4mm);
\end{tikzpicture}

\end{document}

A variety of workarounds (reference example, chains, matrices, etc.)
for the issue at hand is known. But while I have solved it for my own
use, these workarounds tend to be more verbose and I don't need their
extra features.

Thanks
Marcus

------------------------------------------------------------------------------
a free event focused on virtualization and cloud computing.
http://p.sf.net/sfu/redhat-sfdev2dev

Gmane


text:
Posted in Deep Foundations, Geotechnical Engineering

## It’s Coming: Geotechnical Analysis One Grain at a Time

In going through some papers, I noticed this one, Friction anlysis of large diameter steel cylinder penetration process using 3D-DEM, whose abstract is as follows:

Large open-ended cylinder piles have been widely used for engineering foundation of port. The penetration process of the large-diameter steel cylinder exhibit complex behaviors, which is difficult to be measured by test and reproduced in numerical models. This study presents a friction analysis of large diameter steel penetration process by using the discrete element method (DEM), which can simulate large deformation and nonlinearity well. Centrifugal model and full-scale model were developed to analyze the sliding friction of the cylinder during installation and the contact force chain of soil particles. The validity of the DEM model was examined by comparing with theoretical values and published studies. Parametric studies were carried out to study the effects of contact parameters on side friction. Simulation results showed that, unlike pile penetration, there is no obvious soil-plug effect during the penetration process of large-diameter steel cylinder. Besides, the inside friction is smaller than the outside friction for large-diameter steel cylinder. What’s more, the computational cost of full-scale model based on the upscale theory was less than the centrifugal model. There is a close relationship between the side friction and micro contact parameters, which provides a reference for the follow-up study of cylinder or pile penetration using DEM.

Friction anlysis of large diameter steel cylinder penetration process using 3D-DEM

Put into simple terms, DEM models the soil by a grain-by-grain analysis of its response to load, which in this case came from 22 m O.D. open-ended pipe piles for the Hong Kong-Zhuhai-Macau Bridge. Believe it or not, I seriously considered using something like this for the STADYN project, but was dissuaded from doing so because of complexity and stability issues. That’s probably for the best, because the program I was in encouraged a “roll your own” approach to computer code, and to be honest at my stage in life and background I wasn’t up to such a development.

One thing that helped the authors of this paper was the fact that the soils they were driving into was cohesionless, without the chemical bonding that comes with cohesive soils. It’s also interesting to note that these piles were vibrated into place; the whole subject of vibratory driving, its performance prediction and static capacity determination, is another long-running subject in this business.

Although the issues of cohesion and verification (always the fun part of geotechincal engineering) need further resolution, DEM is, in my opinion, the ultimate solution of the soil interaction question, and needs to be disseminated further in our industry.

Posted in Deep Foundations

## Mary Ellen Large Joins Nicholson Construction — GeoPrac.net

Geotechnical specialty engineering and construction contractor Nicholson Construction is pleased to announce the addition of industry expert Mary Ellen Large, P.E, D.GE to the team. Ms. Large will be assuming the role of Client Care […]

Mary Ellen Large Joins Nicholson Construction — GeoPrac.net

Until recently she was Technical Activities Director for the Deep Foundations Institute, a fact which takes some digging to ascertain on their website.

## Reconstructing a Soviet-Era Plastic Model to Predict Vibratory Pile Driving Performance — vulcanhammer.info

The latest in our series of monographs on vibratory pile drivers, this one takes us back to the beginnings of vibratory pile driving in the Soviet Union. It was prepared for the ReSEARCH Dialogues at the University of Tennessee at Chattanooga in April 2021. The vibratory driver that started it all: the Soviet BT-5, used […]

Reconstructing a Soviet-Era Plastic Model to Predict Vibratory Pile Driving Performance — vulcanhammer.info
Posted in Deep Foundations

## Video of 2011 Pile Load Test Failure in Singapore — GeoPrac.net

A static load test was being performed on (presumably) a group of piles at a construction site on Gilstead Road in Singapore in 2011 when the massive pile of concrete blocks toppled over, blocking the […]

Video of 2011 Pile Load Test Failure in Singapore — GeoPrac.net
Posted in Deep Foundations, Geotechnical Engineering

## Vesić’s Method of Estimating the Settlement of Driven Piles and Drilled Shafts

Today for serious projects, if one wants to estimate the settlement of a deep foundation, one uses a “t-z” method of some kind. These methods involve analyzing the pile-soil interaction (and the internal flexibility of the pile) to develop a load-settlement curve similar to one obtained with a static load test. There are several types of algorithms available for this purpose, and they work in different ways.

But what if one wants a “back of the envelope” estimate of the settlement of a deep foundation, or possibly a preliminary load-settlement curve? As is frequently the case with geotechnical engineering, there is more than one way to do this, but probably the simplest–and well represented in practice–is Vesić’s Method, named after Aleksandar Vesić. The method is presented here as shown in NAVFAC DM 7.02, but it appears in other publications and textbooks.

First, we’ll present the method itself:

Let’s break this down: first, it’s necessary to identify some parameters.

• Ultimate static capacity of the shaft $Q'_s$. It isn’t necessary to split up the shaft resistance further along the length; that problem will be handled by other factors. Note that this is a primed variable, and not directly entered into the equations. This will be explained shortly. The method handles toe resistance differently; it is necessary to compute the ultimate unit toe resistance $q_0$, which is usually a result of whatever method you choose to compute the ultimate static capacity of the pile.
• Pile geometry, including length $L$, cross-sectional area $A$, pile “diameter” $B$, length of the pile embedded into the soil $D$ and modulus of elasticity of the pile $E_s$. The method assumes a uniform cross-section and material for the entire pile length.
• The factor $\alpha$, which considers the distribution of soil resistance along the shaft. For a uniform stratum, conventional wisdom has been that sandy soils will have a triangular distribution (due to the dependence of shaft resistance from effective stress) and clay soils a uniform distribution, as the resistance is based on the soil cohesion. However, since Burland, that notion has been challenged, and has created something of a controversy. The best resolution, as shown by the current API method and Kolk and van der Velde, is that the adhesion itself varies with effective stress; it’s not really an either/or, but a both/and situation. Unless the soil data indicates otherwise, the simplest way to resolve this is to say that the default value of $\alpha = \frac{2}{3}$.
• The variable $C_p$, given in the table above.

The simplest way to illustrate how this method works is through an example. Consider the case of a 16″ square concrete pile, 125′ long, driven into loose sands. We want to estimate the settlement of the pile under two axial loads: 400 kips and 600 kips. The water table is at the surface. From the TAMWAVE program, we learn the following:

1. Ultimate shaft resistance $Q'_s = 527.95\,kips$.
2. Unit toe resistance $q_0 = 238.0\,ksf$.
3. Pile length $L = 125'$.
4. Pile cross-sectional area $A = 1.778\,ft^2$.
5. Pile “diameter” $B = 1.333\,ft$.
6. Embedment of pile into soil $D = 125'$ (TAMWAVE only analyses groundline piles.)
7. Modulus of elasticity of pile $E_s = 719,910\,ksf$.
8. Shaft distribution factor $\alpha = 0.667$.
9. Settlement coefficient $C_p = 0.04$.

With that out of the way, we can proceed; however, at this point we get to the tricky part of this method, namely computing $Q_s$ and $Q_p$. This is where students get tripped up, but the root problem is how we look at the “capacity” of deep foundations.

Static capacity methods imply that there is “a number” which represents the static capacity of a pile. They also imply that this capacity is divided neatly between shaft and toe resistance. The truth is that neither is the case; a deep foundation is loaded progressively and the resistance is mobilised progressively, and you end up with a load-displacement relationship from which you determine the maximum permissible load of the foundation.

Vesić’s Method replicates that by the way that $Q_s$ and $Q_p$ are computed, and it is as follows:

• $Q_s$ is either a) equal to the applied load $Q_{applied}$ if $Q'_s > Q_{applied}$ or b) equal to $Q'_s$ if $Q'_s > Q_{applied}$.
• $Q_p$ is either a) equal to zero, if $Q'_s$ if $Q'_s > Q_{applied}$ or b) equal to $Q_{applied} - Q'_s$ if $Q'_s > Q_{applied}$ .

With those definitions, the first thing we do is to compute the coefficient $C_s$. By substitution of the given variables into the equation above, $C_s = 0.64$.

Then for the case of $Q_{applied} = 400\,kips$, since $Q'_s > Q_{applied}$ , $Q_s = 400\,kips$ and $Q_p = 0$. Substitution of these values along with those given or computed above yields the following:

• $W_s = 0.026'$
• $W_{pp} = 0$
• $W_{ps} = 0.009'$
• $W_o = 0.026 + 0 + 0.009 = 0.035' = 0.416"$

Turning now to the case of $Q_{applied} = 600\,kips$, since $Q'_s < Q_{applied}$, $Q_s = 527.95\,kips$ and $Q_p = 600 - 527.95 = 72.05\,kips$. Substitution of these values along with those given or computed above yields the following:

• $W_s = 0.041'$
• $W_{pp} = 0.009'$
• $W_{ps} = 0.011'$
• $W_o = 0.041 + 0.009 + 0.011 = 0.062' = 0.742"$

It should be evident that, if these calculations are repeated for a range of $Q_{applied}$, a load-settlement curve could be developed, and in fact this has been done and it is documented on this spreadsheet. In addition to Vesić’s Method being shown, the results of TAMWAVE (which uses a numerical t-z method to develop the load-settlement curve) are also included, and the results are shown below.

With this the following should be noted:

• The results in the range which the two methods share are similar, especially with the “break point” where shaft resistance is maximised and toe resistance starts to kick in.
• The t-z method which TAMWAVE uses assumes a purely plastic response once the ultimate static capacity is exceeded, i.e. plunging failure. Vesić’s Method does not, and in many cases this is more realistic.
• The TAMWAVE method has an unloading curve which is not shown here, which Vesić’s Method does not replicate.
• It is possible to apply a static load test criterion (such as Davisson’s Method) to either or both of these results. It should be expected that the ultimate load derived in this way is different from the ultimate load computed by the static capacity method.

From this we can see that Vesić’s Method is a useful tool to find an initial estimate of the load-settlement characteristics of either driven or bored piles. The difficult part is grasping the method by which Vesić’s Method models progressive mobilisation of the shaft and toe resistance. Doing this, however, can give us a better understand of the whole concept of resistance mobilisation, which is crucial in understand how deep foundations resist and transfer loads.


text:
# 100 Locker Problem Expanded

The locker problem for 100 lockers is simple:

A school has 100 lockers and 100 students. All lockers are closed on the first day of school. As the students enter, the first student, denoted S1, opens every locker. Then the second student, S2, begins with the second locker, denoted L2, and closes every other locker. Student S3 begins with the third locker and changes every third locker (closes it if it was open, and opens it if it was closed). Student S4 begins with locker L4 and changes every fourth locker. Student S5 starts with L5 and changes every fifth locker, and so on, until student S100 changes L100.

Which lockers will remain open?

Now my program in Python uses a trick hidden in this problem which is that all lockers whose numbers have an odd number of divisors will remain open. In other words, lockers whose numbers are perfect squares. This allowed me to expand my program to solve the problem for any $x$ amount of lockers, provided by the user:

# 100 Locker Problem

counter_open = 0
counter_close = 0
open_list = []

def locker(num_lockers):
global counter_open, counter_close
num = 1
while num**2 < num_lockers:
open_list.append(num**2)
num += 1
counter_open = len(open_list)
counter_close = num_lockers - len(open_list)

def run():
global open_list, counter_close, counter_open
open_list = []
counter_open = 0
counter_close = 0
endings = ["st", "nd", "rd", "th"]
try:
user_input = int(raw_input("How many lockers will there be: "))
except ValueError:
else:
locker(user_input)
return_str = "The "
for index in range(0, len(open_list)):
if index == (len(open_list) - 1):
if str(open_list[index])[-1:] == "1":
return_str += ("and " + str(open_list[index]) + endings[0])
elif str(open_list[index])[-1:] == "2":
return_str += ("and " + str(open_list[index]) + endings[1])
elif str(open_list[index])[-1:] == "3":
return_str += ("and " + str(open_list[index]) + endings[2])
else:
return_str += ("and " + str(open_list[index]) + endings[3])
else:
if str(open_list[index])[-1:] == "1":
return_str += (str(open_list[index]) + endings[0] + ", ")
elif str(open_list[index])[-1:] == "2":
return_str += (str(open_list[index]) + endings[1] + ", ")
elif str(open_list[index])[-1:] == "3":
return_str += (str(open_list[index]) + endings[2] + ", ")
else:
return_str += (str(open_list[index]) + endings[3] + ", ")
return_str += " locker(s) will be open."
print return_str

while True:
run()
print "Open Lockers: " + str(counter_open)
print "Closed Locker: " + str(counter_close)
print "----------------------------"

Yes, I do realize that I am using global in my functions and I have 8 if/elif statements for grammar but accuracy in the result (and PEP 8) is key to me (keep that in mind) . How do I improve the efficiency of the code and/or shorten the code?

Algorithm

The beginning of the mathematical analysis is very nice and well explained. Maybe it would be nice to have it in your code as a comment.

Also, please note that if what you really care about is the number of lockers open (or closed), it is just a matter of computing a square root.

Separation of concerns

The biggest issue in your code is that you have a function doing everything : handling user input, string formatting, updating globals... This makes your code hard to follow and hard to test. A better way to do it would be to have smaller units (functions or sometimes classes and modules) with a single responsability.

By doing so, you could get rid of the globals and write the code like this :

# 100 Locker Problem

def get_open_lockers(num_lockers):
open_list = []
num = 1
while num**2 < num_lockers:
open_list.append(num**2)
num += 1
return open_list

def format_output(nb_lockers, open_list):
endings = ["st", "nd", "rd", "th"]
counter_open = len(open_list)
counter_close = nb_lockers - counter_open
return_str = "The "
for index in range(0, len(open_list)):
if index == (len(open_list) - 1):
if str(open_list[index])[-1:] == "1":
return_str += ("and " + str(open_list[index]) + endings[0])
elif str(open_list[index])[-1:] == "2":
return_str += ("and " + str(open_list[index]) + endings[1])
elif str(open_list[index])[-1:] == "3":
return_str += ("and " + str(open_list[index]) + endings[2])
else:
return_str += ("and " + str(open_list[index]) + endings[3])
else:
if str(open_list[index])[-1:] == "1":
return_str += (str(open_list[index]) + endings[0] + ", ")
elif str(open_list[index])[-1:] == "2":
return_str += (str(open_list[index]) + endings[1] + ", ")
elif str(open_list[index])[-1:] == "3":
return_str += (str(open_list[index]) + endings[2] + ", ")
else:
return_str += (str(open_list[index]) + endings[3] + ", ")
return_str += " locker(s) will be open."
print return_str
print "Open Lockers: " + str(counter_open)
print "Closed Locker: " + str(counter_close)
print "----------------------------"

while True:
try:
nb_lockers = int(raw_input("How many lockers will there be: "))
except ValueError:
else:
open_list = get_open_lockers(nb_lockers)
format_output(nb_lockers, open_list)

Look like a native

Almost everytime you do range(len(list)), you are not doing things the right way. I highly recommend Ned Batchelder's excellent talk called "Loop like a native".

In your case, the code becomes (l stands for locker which is probably not the best name):

def format_output(nb_lockers, open_list):
endings = ["st", "nd", "rd", "th"]
counter_open = len(open_list)
counter_close = nb_lockers - counter_open
return_str = "The "
for i, l in enumerate(open_list):
if i == (len(open_list) - 1):
if str(l)[-1:] == "1":
return_str += ("and " + str(l) + endings[0])
elif str(l)[-1:] == "2":
return_str += ("and " + str(l) + endings[1])
elif str(l)[-1:] == "3":
return_str += ("and " + str(l) + endings[2])
else:
return_str += ("and " + str(l) + endings[3])
else:
if str(l)[-1:] == "1":
return_str += (str(l) + endings[0] + ", ")
elif str(l)[-1:] == "2":
return_str += (str(l) + endings[1] + ", ")
elif str(l)[-1:] == "3":
return_str += (str(l) + endings[2] + ", ")
else:
return_str += (str(open_list[i]) + endings[3] + ", ")
return_str += " locker(s) will be open."
print return_str
print "Open Lockers: " + str(counter_open)
print "Closed Locker: " + str(counter_close)
print "----------------------------"

Extra Operations (functions calls and slicing)

You keep converting l to str. Maybe you could it once and for all.

Similarly, you keep accessing string[-1:] : it would be nice to do it only once. By the way, the usual way to get the last elements of the list is just [-1] (no need for colon).

def format_output(nb_lockers, open_list):
endings = ["st", "nd", "rd", "th"]
counter_open = len(open_list)
counter_close = nb_lockers - counter_open
return_str = "The "
for i, l in enumerate(open_list):
s = str(l)
last_dig = s[-1]
if i == (len(open_list) - 1):
if last_dig == "1":
return_str += ("and " + s + endings[0])
elif last_dig == "2":
return_str += ("and " + s + endings[1])
elif last_dig == "3":
return_str += ("and " + s + endings[2])
else:
return_str += ("and " + s + endings[3])
else:
if last_dig == "1":
return_str += (s + endings[0] + ", ")
elif last_dig == "2":
return_str += (s + endings[1] + ", ")
elif last_dig == "3":
return_str += (s + endings[2] + ", ")
else:
return_str += (s + endings[3] + ", ")
return_str += " locker(s) will be open."
print return_str
print "Open Lockers: " + str(counter_open)
print "Closed Locker: " + str(counter_close)
print "----------------------------"

Don't repeat yourself

Your have similar logic in the then and else blocks in format_output. This could be factorised out. Also, it would be a good idea to take this chance to extract it out in a function on its own.

def int_to_ordinal(n):
endings = ["st", "nd", "rd", "th"]
s = str(n)
last_dig = s[-1]
if last_dig == "1":
return s + endings[0]
elif last_dig == "2":
return s + endings[1]
elif last_dig == "3":
return s + endings[2]
else:
return s + endings[3]

def format_output(nb_lockers, open_list):
counter_open = len(open_list)
counter_close = nb_lockers - counter_open
return_str = "The "
for i, l in enumerate(open_list):
if i == (len(open_list) - 1):
return_str += ("and " + int_to_ordinal(l))
else:
return_str += (int_to_ordinal(l) + ", ")
return_str += " locker(s) will be open."
print return_str
print "Open Lockers: " + str(counter_open)
print "Closed Locker: " + str(counter_close)
print "----------------------------"

Tiny bug

I've just discovered one bug as I was trying to go further. I imagine it was in the original code but I might be wrong. It happens when there is only one lock open (the first), the formatting gives : "The and 1st locker(s) will be open." which looks a bit weird.

PEP8 and join

There is a style guide for Python code called PEP 8 : it is worth reading (and worth following as much as possible). Your code seems to follow the PEP 8 style for most parts but there is a part you'd be interested in:

For example, do not rely on CPython's efficient implementation of in-place string concatenation for statements in the form a += b or a = a + b . This optimization is fragile even in CPython (it only works for some types) and isn't present at all in implementations that don't use refcounting. In performance sensitive parts of the library, the ''.join() form should be used instead. This will ensure that concatenation occurs in linear time across various implementations.

Even though I can safely assume that your code performance is not that important, the join builtin, on top of making your code faster, can make it clearer. You could write something like:

def format_output(nb_lockers, open_list):
counter_open = len(open_list)
counter_close = nb_lockers - counter_open
print "The " + ", ".join(int_to_ordinal(l) for l in open_list) + " locker(s) will be open."
print "Open Lockers: " + str(counter_open)
print "Closed Locker: " + str(counter_close)
print "----------------------------"

(I removed the part with the "And" because it seemed buggy anyway).

If main

In Python, it is recommended to put the part of your code that actually does something (instead of merely defining something) behind an if __name__ == "__main__": so that you can easily run your code as a main program but also import it to be able to reuse the functions/classes you've defined.

if __name__ == "__main__":
while True:
try:
nb_lockers = int(raw_input("How many lockers will there be: "))
except ValueError:
else:
open_list = get_open_lockers(nb_lockers)
format_output(nb_lockers, open_list)

Optimisation in get_open_lockers

In get_open_locks, you can easily compute the number of iterations you'll need. Also, you could use a list comprehension to avoid calling append many times.

import math

def get_open_lockers(num_lockers):
if num_lockers <= 0:
return []
sqrt = int(math.sqrt(num_lockers-1))
return [i*i for i in range(1, sqrt+1)]

(It is easy to write tests to ensure that the function returns the same resultats before and after)

Final version of the code

My final code looks like (it can still probably be improved):

import math

def get_open_lockers(num_lockers):
if num_lockers <= 0:
return []
sqrt = int(math.sqrt(num_lockers-1))
return [i*i for i in range(1, sqrt+1)]

def int_to_ordinal(n):
endings = ["st", "nd", "rd", "th"]
s = str(n)
last_dig = s[-1]
if last_dig == "1":
return s + endings[0]
elif last_dig == "2":
return s + endings[1]
elif last_dig == "3":
return s + endings[2]
else:
return s + endings[3]

def format_output(nb_lockers, open_list):
counter_open = len(open_list)
counter_close = nb_lockers - counter_open
print "The " + ", ".join(int_to_ordinal(l) for l in open_list) + " locker(s) will be open."
print "Open Lockers: " + str(counter_open)
print "Closed Locker: " + str(counter_close)
print "----------------------------"

if __name__ == "__main__":
while True:
try:
nb_lockers = int(raw_input("How many lockers will there be: "))
except ValueError:
else:
open_list = get_open_lockers(nb_lockers)
format_output(nb_lockers, open_list)

Avoid alternation by expanding the endings array to cover all 10 endings as follows:

def int_to_ordinal(n):
endings = ["th", "st", "nd", "rd", "th", "th", "th", "th", "th", "th"]
s = str(n)
last_dig = s[-1]
ord = int(last_dig)
return s + endings[ord]

Of course this does not correct the misnaming of the teens where 11, 12 and 13 are returned as "11st", "12nd" and "13rd" respectively whenever they are the last two digits in the argument.

• Or Use return endings.get(str(n)[-1], "th"), by making endings a dictionary and get rid of all th. – Graipher Dec 20 '16 at 9:24


text:
# Complexity of type-checking in relation to complexity of normalization

In order to verify that a terminating program terminates, one thing that can be done is to actually run the program. That may take a lot of time. If the program is typed in a total type-system, we can instead just type-check the program. That will take some time too, sometimes "a lot" too.

I'm looking for results that formalize the relation of the complexity of type-checking to the complexity of normalization for a various type-systems, i.e. possible speedup ratios. Is that relation always well defined? I'm not sure.

But we can give some lower bounds by demonstrating families of typed terms.

I'm interested mostly in any of the well known type systems such as System F, predicative variants of system F, including 'Rank 1' variant and Calculus of constructions. 'Intersection types' are particularly interesting case since they characterize the family of normalizing lambda terms.

The relationship that you're looking for is indeed well-defined, but IMO it's not quite the right thing to look at. For example:

1. Type checking for terms in the simply-typed lambda calculus is linear time, but normalizing terms in the STLC exceeds any fixed tower of exponentials (i.e., $O(2^{2^{2^{\ldots n}}})$.
2. Type checking for System F is linear time, but normalization takes as long as any function definable in second-order arithmetic.
3. For $F^\omega$, typechecking exceeds any tower of exponentials (since you have to normalize simply-typed lambda-terms to do typechecking), but normalization is complete for higher-order arithmetic.
4. Type inference for rank-1 types (basically, ML-style types) is EXPTIME-complete, but normalization time is somewhere in between the STLC and System F.
5. Type inference for intersection types is undecidable (because they characterize halting).

What's going on here is that once you add enough type annotations, typechecking gets easy. If you have to do inference, then the problem gets much harder. This hints that there's a connection between program analysis and evaluation, and the ability of intersection type disciplines to characterize normalization further hints that the key place to look is linear logic.

• A good place to get an intuition is from David Van Horn and Harry Mairson's papers Flow Analysis, Linearity, and PTIME and Relating complexity and precision in control flow analysis.

These papers show that for a linear calculus, program analysis and evaluation coincide, because linearity makes the approximation of flow analysis exact.

• So by taking a linear calculus and then carefully controlling how much contraction you have via intersection types, you can gain a rather fine control over the complexity of normalization. As you might expect, there is an awful lot of work in this space from the intersection types community.

So rather than trying to summarize it all and missing important references, I'll pick out one line of work I particularly like (and thereby miss important references on purpose :). This is the work of Damiano Mazza on redoing classical complexity theory in a higher-order implicit complexity framework. Here are three papers I particularly like:

1. Church meets Cook and Levin. This re-does the famous Cook-Levin proof (that SAT is NP-complete) in an implicit complexity style. The key idea is that you can use affine lambda terms as a kind of "higher-order circuit", and then approximate regular lambda-terms using them.
2. This idea is explored further in Non-linearity as the Metric Completion of Linearity, which focuses just on this idea (apparently implicit in Girard).
3. Most recently at POPL this year, Mazza (with Luc Pellissier and Pierre Vial) showed how most linear intersection type systems arise from a general framework for refinement types introduced by Noam Zeilberger and Paul-André Melliès, in their paper Polyadic Approximations, Fibrations and Intersection Types.

I want to emphasize that this is not comprehensive -- chase the references in these papers!

• Neel, the references you gave are excellent! – Łukasz Lew Aug 14 '18 at 2:31
• Would you also be able to comment more on the opposite end of the spectrum? Why System F jump [linear -> second order arithmetic] is so big? Perhaps it is the biggest jump possible in some sense? I've read all kinds of related arguments demonstrating impredicativity, but I'm looking for something that would demonstrate how the number of contractions is controlled. – Łukasz Lew Aug 14 '18 at 2:40


text:
# Truncated cuboctahedron

In geometry, the truncated cuboctahedron is an Archimedean solid, named by Kepler as a truncation of a cuboctahedron. It has 12 square faces, 8 regular hexagonal faces, 6 regular octagonal faces, 48 vertices and 72 edges. Since each of its faces has point symmetry (equivalently, 180° rotational symmetry), the truncated cuboctahedron is a zonohedron. The truncated cuboctahedron can tessellate with the octagonal prism.

Truncated cuboctahedron

TypeArchimedean solid
Uniform polyhedron
ElementsF = 26, E = 72, V = 48 (χ = 2)
Faces by sides12{4}+8{6}+6{8}
Conway notationbC or taC
Schläfli symbolstr{4,3} or ${\displaystyle t{\begin{Bmatrix}4\\3\end{Bmatrix}}}$
t0,1,2{4,3}
Wythoff symbol2 3 4 |
Coxeter diagram
Symmetry groupOh, B3, [4,3], (*432), order 48
Rotation groupO, [4,3]+, (432), order 24
Dihedral angle4-6: arccos(−6/3) = 144°44′08″
4-8: arccos(−2/3) = 135°
6-8: arccos(−3/3) = 125°15′51″
ReferencesU11, C23, W15
PropertiesSemiregular convex zonohedron

Colored faces

4.6.8
(Vertex figure)

Disdyakis dodecahedron
(dual polyhedron)

Net

## Names

 The name truncated cuboctahedron, given originally by Johannes Kepler, is misleading. An actual truncation of a cuboctahedron has rectangles instead of squares. This nonuniform polyhedron is topologically equivalent to the Archimedean solid. Alternate interchangeable names are: Truncated cuboctahedron (Johannes Kepler) Rhombitruncated cuboctahedron (Magnus Wenninger[1]) Great rhombicuboctahedron (Robert Williams[2]) Great rhombcuboctahedron (Peter Cromwell[3]) Omnitruncated cube or cantitruncated cube (Norman Johnson) Beveled cube (Conway polyhedron notation) .mw-parser-output .tmulti .thumbinner{display:flex;flex-direction:column}.mw-parser-output .tmulti .trow{display:flex;flex-direction:row;clear:left;flex-wrap:wrap;width:100%;box-sizing:border-box}.mw-parser-output .tmulti .tsingle{margin:1px;float:left}.mw-parser-output .tmulti .theader{clear:both;font-weight:bold;text-align:center;align-self:center;background-color:transparent;width:100%}.mw-parser-output .tmulti .thumbcaption{text-align:left;background-color:transparent}.mw-parser-output .tmulti .thumbcaption-center{text-align:center;background-color:transparent}.mw-parser-output .tmulti .text-align-left{text-align:left}.mw-parser-output .tmulti .text-align-right{text-align:right}.mw-parser-output .tmulti .text-align-center{text-align:center}@media all and (max-width:720px){.mw-parser-output .tmulti .thumbinner{width:100%!important;box-sizing:border-box;max-width:none!important;align-items:center}.mw-parser-output .tmulti .trow{justify-content:center}.mw-parser-output .tmulti .tsingle{float:none!important;max-width:100%!important;box-sizing:border-box;text-align:center}.mw-parser-output .tmulti .thumbcaption{text-align:center}}Cuboctahedron and its truncation

There is a nonconvex uniform polyhedron with a similar name, the nonconvex great rhombicuboctahedron.

## Cartesian coordinates

The Cartesian coordinates for the vertices of a truncated cuboctahedron having edge length 2 and centered at the origin are all permutations of:

(±1, ±(1 + 2), ±(1 + 22))

## Area and volume

The area A and the volume V of the truncated cuboctahedron of edge length a are:

{\displaystyle {\begin{aligned}A&=12\left(2+{\sqrt {2}}+{\sqrt {3}}\right)a^{2}&&\approx 61.755\,1724a^{2}\\V&=\left(22+14{\sqrt {2}}\right)a^{3}&&\approx 41.798\,9899a^{3}.\end{aligned}}}

## Dissection

The truncated cuboctahedron is the convex hull of a rhombicuboctahedron with cubes above its 12 squares on 2-fold symmetry axes. The rest of its space can be dissected into 6 square cupolas below the octagons and 8 triangular cupolas below the hexagons.

A dissected truncated cuboctahedron can create a genus 5, 7 or 11 Stewart toroid by removing the central rhombicuboctahedron and either the square cupolas, the triangular cupolas or the 12 cubes respectively. Many other lower symmetry toroids can also be constructed by removing a subset of these dissected components. For example, removing half of the triangular cupolas creates a genus 3 torus, which (if they are chosen appropriately) has tetrahedral symmetry.[4][5]

## Uniform colorings

There is only one uniform coloring of the faces of this polyhedron, one color for each face type.

A 2-uniform coloring, with tetrahedral symmetry, exists with alternately colored hexagons.

## Orthogonal projections

The truncated cuboctahedron has two special orthogonal projections in the A2 and B2 Coxeter planes with [6] and [8] projective symmetry, and numerous [2] symmetries can be constructed from various projected planes relative to the polyhedron elements.

Orthogonal projections
Centered by Vertex Edge
4-6
Edge
4-8
Edge
6-8
Face normal
4-6
Image
Projective
symmetry
[2]+ [2] [2] [2] [2]
Centered by Face normal
Square
Face normal
Octagon
Face
Square
Face
Hexagon
Face
Octagon
Image
Projective
symmetry
[2] [2] [2] [6] [4]

## Spherical tiling

The truncated cuboctahedron can also be represented as a spherical tiling, and projected onto the plane via a stereographic projection. This projection is conformal, preserving angles but not areas or lengths. Straight lines on the sphere are projected as circular arcs on the plane.

## Full octahedral group

Like many other solids the truncated octahedron has full octahedral symmetry - but its relationship with the full octahedral group is closer than that: Its 48 vertices correspond to the elements of the group, and each face of its dual is a fundamental domain of the group.

The image on the right shows the 48 permutations in the group applied to an example object (namely the light JF compound on the left). The 24 light elements are rotations, and the dark ones are their reflections.

The edges of the solid correspond to the 9 reflections in the group:

• Those between octagons and squares correspond to the 3 reflections between opposite octagons.
• Hexagon edges correspond to the 6 reflections between opposite squares.
• (There are no reflections between opposite hexagons.)

The subgroups correspond to solids that share the respective vertices of the truncated octahedron.
E.g. the 3 subgroups with 24 elements correspond to a nonuniform snub cube with chiral octahedral symmetry, a nonuniform truncated octahedron with full tetrahedral symmetry and a nonuniform rhombicuboctahedron with pyritohedral symmetry (the cantic snub octahedron).
The unique subgroup with 12 elements is the alternating group A4. It corresponds to a nonuniform icosahedron with chiral tetrahedral symmetry.

 Bowtie tetrahedron and cube contain two trapezoidal faces in place of the square.[6]

The truncated cuboctahedron is one of a family of uniform polyhedra related to the cube and regular octahedron.

This polyhedron can be considered a member of a sequence of uniform patterns with vertex configuration (4.6.2p) and Coxeter-Dynkin diagram . For p < 6, the members of the sequence are omnitruncated polyhedra (zonohedrons), shown below as spherical tilings. For p < 6, they are tilings of the hyperbolic plane, starting with the truncated triheptagonal tiling.

It is first in a series of cantitruncated hypercubes:

 Truncated cuboctahedron Cantitruncated tesseract Cantitruncated 5-cube Cantitruncated 6-cube Cantitruncated 7-cube Cantitruncated 8-cube

## Truncated cuboctahedral graph

Truncated cuboctahedral graph
4-fold symmetry
Vertices48
Edges72
Automorphisms48
Chromatic number2
PropertiesCubic, Hamiltonian, regular, zero-symmetric
Table of graphs and parameters

In the mathematical field of graph theory, a truncated cuboctahedral graph (or great rhombcuboctahedral graph) is the graph of vertices and edges of the truncated cuboctahedron, one of the Archimedean solids. It has 48 vertices and 72 edges, and is a zero-symmetric and cubic Archimedean graph.[7]


text:
Writing and performing algorithms

During the past week, I’ve spent a lot of time trying to look through this website and trying to improve it.  I am hoping to provide the most convenient and useful experience as possible.  While WordPress has done a wonderful job providing the structure needed to set up a very good website without coding, I still wanted to customize the website further.  In order to do so, I did indeed need to go through code and make small changes.  Even though this wasn’t an extensive project, it was still fun to go through and have to problem solve and code for the website.  During this process, I was reminded again of the daily interaction we have with technology.  Furthermore, even though most of this works without a second thought, there are still times where it can be extremely helpful to understand some coding so that you can get your devices to do what you want them to.

While I don’t teach computer science, I do teach my students many of the same concepts that they will need in order to write a computer program.  In many ways, writing and solving equations is equivalent to writing and performing a code you would want a computer to do.  Here, I will go over some of the ways I’ve been able to explain these processes to (college) students.

Algorithms

The first thing that people tend to forget about computers, is that they really aren’t intelligent.  They are just really good at following directions and performing the same task repetitively.  This is both wonderful and extremely frustrating at the same time.  That is, if you tell a computer to do something, it will do exactly as you say, even if you don’t say what you actually mean.  In this way, in order to be able to work with machines, you really need to know how to explain exactly what you want done and what order it should be done in.

The instructions that you would provide to a computer, or a person, in order to have a task completed is called an algorithm.  The first step in being able to write an algorithm is being able to follow one.  For historical context, the word algorithm is derived from al-Khwarizmi (780-850), the author of al-Jabr (which later turned into algebra) (A history of mathematics).  In al-Jabr, al-Khwarizmi describes to the reader the process required to solve quadratic equations.  Because of this, the algorithm I choose for my students to go through first is one similar to what was described in al-Jabr.  That is, while I use modern notation and conventions, I use his technique to solve the quadratic equation.

In order to complete an algorithm, we will need some type of input.  After the process, we will then have an output.  We then have:

• Take input of $$ax^{2}+bx+c$$.
• Define $$a$$ as the coefficient of $$x^{2}$$, $$b$$ as the coefficient of $$x$$ and $$c$$ as the constant term in the equation.
• Take $$b$$ and divide by $$a$$, let this value now be $$b$$.
• Take $$c$$ and divide by $$a$$, let this value now be $$c$$.
• Take $$b$$ and divide by $$2$$, let this value now be $$b$$.
• Square $$b$$, assign this new value to $$y$$.
• Take $$c$$ and subtract $$y$$.  Assign this value to $$y$$.
• If $$y \geq 0$$, then
• Take the square root of $$y$$.  Assign this to $$y$$.
• Subtract the current value of $$b$$ from $$y$$.  Assign this value to $$y_{1}$$.
• Multiply $$y$$ by negative 1.
• Subtract the current value of $$b$$ from $$y$$.  Assign this value to $$y_{2}$$.
• Assign the pair $$(y_{1},y_{2})=y$$.
• else
• Assign $$y$$ the value, no answer.
• Output $$y$$.

If we follow this algorithm, we will have a pair of number $$y_{1},y_{2}$$ such that $$ay_{1}^{2}+by_{1}+c=ay_{2}^{2}+by_{2}+c=0$$ or we will be told there is no such answer.  Furthermore, we will have $$y_{1}=y_{2}$$ if there is only one solution to the equation.

This may not look like the quadratic equation that you have seen; however, if you leave $$a,b$$ and $$c$$ as is, the $$y_{1},y_{2}$$ will be precisely the solutions $$y_{1}=\frac{-b+\sqrt{b^{2}-4ac}}{2a}$$ and $$y_{2}=\frac{-b-\sqrt{b^{2}-4ac}}{2a}$$.  I like to use this as an initial example for two reasons.  First, as I let the students work in groups, they can check their work when they are done to see if they followed the algorithm correctly.  Secondly, I like to make the point to them that the written instruction may not appear to follow the same outline as an equation.  This can be because it might arrive at the answer a different way, or because it is strange to see equations in sentences.  We indeed have both of these factors to worry about in the above algorithm.

Having them write an algorithm

Now that I have had my students work through an algorithm, I now hand it off to them to try to write such an algorithm.  In order to do this I will split them up into groups again and have them move so that they cannot eavesdrop on each other.  I will then give each of them a task they need to describe and have them write an algorithm.  The other group will be given a different task they need to write an algorithm for.  At this point, I don’t tell them this; however, after they have been given time to complete writing the algorithms, I take the written portion from groups and give it to another group with an input, but no context and ask them to complete the task.

For this situation, some of the tasks I will give are,

• Suppose that you are given a set of real numbers $$\left\{x_{1},x_{2}, \ldots x_{n}\right\}$$.  Write an algorithm to explain how to find the smallest number in the list.  Note that your steps may only compare at most 2 numbers at a time (that is you can’t say pick the smallest number of the list).
• Suppose that you are given a natural number $$n$$.  Write an algorithm that will find the first $$n$$ Fibonacci numbers, that is, the sequence $$(1,1,2,3,5,8,11,17, \ldots)$$. (Note here, I tell them that the pattern will continue but not what the pattern is.  In the past I have given the pattern, but as I am used to writing algorithms, I tend to do this in such a way that it gives the answer away.)

These are my favorite two to work with, because, there are relatively few instructions that need to be written.  However, the students will need to describe how to interpret an input, assign variables along the way, repeat a process and describe when to stop the process.  In the writing process, I have found the students often tend to be quite cavalier in how they explains things.  They assume that they would be working with it, so they would know the context in which the instructions were written.

As the students work through the instructions, they will often have difficulties.  If they had difficulties in the first example, they would adjust their techniques to get where they wanted to go, or blame me for writing it poorly.  In this situation, they are left blaming each other for poor writing.  However, since they had just written an algorithm, they will see many similarities.  This usually forces them to realize and admit to their own mistakes.  Seeing how a lack of instruction can affect another person, they tend to be much more careful in the future as we study.

Conclusion

Being able to give and follow precise instructions in an extremely important skill for everyone to have.  The importance of these skills has only grown greater as our lives have become more intertwined with technology and devices that will follow our instructions.  As you try to develop these skills with your students, it will be a long process of trial and error (probably for you and them).  Starting off by giving them a problem to work on without the specific terminology used in algorithms or computer coding helps them to realize the importance of being precise as the go through instructions.  While people can often overcome small omissions, computers can’t.  We can simulate this by not giving students any context within which to work.  I have found this an extremely helpful way to begin algorithms and coding; however, there will be much more to do.

If you would like more teaching resources, we have the STEM and leaf resources available in the shop.  Here, I shared my experiences in college classes.  This would also be appropriate in high school, but we will look at techniques for younger students in the future as well.

1 thought on “Writing and performing algorithms”

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


text:
# How do you solve  3^(2x+1) = 5?

Aug 8, 2016

$x = 0.2326$.

#### Explanation:

${3}^{2 x + 1} = 5$

$\therefore {3}^{2 x} \cdot 3 = 5$

$\therefore {3}^{2 x} = \frac{5}{3}$

$\therefore {\log}_{10} {3}^{2 x} = {\log}_{10} \left(\frac{5}{3}\right)$

$\therefore 2 x \cdot {\log}_{10} 3 = {\log}_{10} 5 - {\log}_{10} 3$

$\therefore 2 x \left(0.4771\right) = 0.6990 - 0.4771$................[Using, Log Tables].

$\therefore 2 x \left(0.4771\right) = 0.2219$

$\therefore {\log}_{10} \left\{\left(2 x\right) \left(0.4771\right)\right\} = {\log}_{10} 0.2219$

$\therefore {\log}_{10} 2 + {\log}_{10} x + {\log}_{10} 0.4771 = {\log}_{10} 0.2219$

$\therefore 0.3010 + {\log}_{10} x + \left(\overline{1}\right) .6786 = \left(\overline{1}\right) .3461 .$

$\therefore {\log}_{10} x + \left(\overline{1}\right) .9796 = \left(\overline{1}\right) .3461$

$\therefore {\log}_{10} x = 0.3461 - 0.9796 = - 0.6335 = \left(\overline{1}\right) .3665$

$\therefore x$=Anti-${\log}_{10} \left(\overline{1}\right) .3665$

$\therefore x = 0.2326$.

Aug 11, 2016

$x = 0.232487$

#### Explanation:

We have an exponential equation, but 5 is not one of the powers of 3, so logs are indicated, especially if the variable is in the index.

${3}^{2 x + 1} = 5$

$\log {3}^{2 x + 1} = \log 5$

$\left(2 x + 1\right) \log 3 = \log 5$

$2 x + 1 = \log \frac{5}{\log}$

There is no law for simplifying #(log)/log), use a calculator or tables.

$2 x + 1 = 1.4649735$

$2 x = 0.464974$

$x = 0.232487$


text:
## Seminars and Colloquia by Series

Wednesday, November 28, 2018 - 12:20 , Location: Skiles 005 , JungHwan Park , Georgia Tech , Organizer: Trevor Gunn
Monday, November 26, 2018 - 13:55 , Location: Skiles 005 , , Texas State University , , Organizer: John McCuan
Friday, November 23, 2018 - 15:00 , Location: None , None , None , Organizer: Lutz Warnke
Monday, November 19, 2018 - 14:00 , Location: Skiles 006 , Livio Liechti , Paris-Jussieu , Organizer: Balazs Strenner
Friday, November 16, 2018 - 15:00 , Location: Skiles 005 , , Georgia Tech , Organizer: Lutz Warnke
Friday, November 16, 2018 - 14:00 , Location: Skiles 006 , Stavros Garoufalidis , Georgia Tech and MPI , Organizer: John Etnyre
I will explain some connections between the counting of incompressible surfaces in hyperbolic 3-manifolds with boundary and the 3Dindex of Dimofte-Gaiotto-Gukov. Joint work with N. Dunfield, C. Hodgson and H. Rubinstein, and, as usual, with lots of examples and patterns.
Friday, November 16, 2018 - 14:00 , Location: Skiles 006 , None , None , Organizer: John Etnyre
Friday, November 16, 2018 - 14:00 , Location: Skiles 005 , , Florida State University , Organizer: Yoav Len
Friday, November 16, 2018 - 11:00 , Location: Skiles 006 , , University of Michigan , , Organizer: Galyna Livshyts
TBA
Thursday, November 15, 2018 - 15:05 , Location: Skiles 006 , Geronimo Uribe , UNAM , , Organizer: Gerandy Brito


text:
Poster
Active Heteroscedastic Regression
Kamalika Chaudhuri · Prateek Jain · Nagarajan Natarajan

Mon Aug 7th 06:30 -- 10:00 PM @ Gallery #138

An active learner is given a model class $\Theta$, a large sample of unlabeled data drawn from an underlying distribution and access to a labeling oracle which can provide a label for any of the unlabeled instances. The goal of the learner is to find a model $\theta \in \Theta$ that fits the data to a given accuracy while making as few label queries to the oracle as possible. In this work, we consider a theoretical analysis of the label requirement of active learning for regression under a heteroscedastic noise model.

Previous work has looked at active regression either with no model mismatch~\cite{chaudhuri2015convergence} or with arbitrary model mismatch~\cite{sabato2014active}. In the first case, active learning provided no improvement even in the simple case where the unlabeled examples were drawn from Gaussians. In the second case, under arbitrary model mismatch, the algorithm either required a very high running time or a large number of labels. We provide bounds on the convergence rates of active and passive learning for heteroscedastic regression, where the noise depends on the instance. Our results illustrate that just like in binary classification, some partial knowledge of the nature of the noise can lead to significant gains in the label requirement of active learning.


text:
# It is difficult to control activities without a budget

True or False

It is difficult to control activities without a budget.


text:
# Connexions

You are here: Home » Content » Confidence Intervals: Practice 1

### Recently Viewed

This feature requires Javascript to be enabled.

### Tags

(What is a tag?)

These tags come from the endorsement, affiliation, and other lenses that include this content.

# Confidence Intervals: Practice 1

Summary: Note: This module is currently under revision, and its content is subject to change. This module is being prepared as part of a statistics textbook that will be available for the Fall 2008 semester.

Note: You are viewing an old version of this document. The latest version is available here.

## Student Learning Outcomes

The student will explore the properties of Confidence Intervals for Averages and gain knowledge of population standard deviation.

## Given

The average age for all Foothill College students for Fall 2005 was 32.7. The population standard deviation has been pretty consistent at 15. Twenty-five Winter 2006 students were randomly selected. The average age for the sample was 30.4. We are interested in the true average age for Winter 2006 Foothill College students. (http://research.fhda.edu/factbook/FHdemofs/Fact_sheet_fh_2005f.pdf)

Let X=X= size 12{X={}} {} the age of a Winter 2006 Foothill College student

## Calculating the Confidence Interval

### Exercise 1

1. x¯=x¯= size 12{ {overline {x}} ={}} {}__________ n=n= size 12{n={}} {} ________ 15 = ___________ (fill in symbol)
2. Define the Random Variable, X¯X¯ size 12{ {overline {X}} } {} , in words. X¯=X¯= size 12{ {overline {X}} ={}} {} ___________________________________________________________
3. What is x¯x¯ size 12{ {overline {x}} } {} estimating?
4. Is σxσx size 12{σ rSub { size 8{x} } } {} known?
5. As a result of your answer to (4), state the exact distribution to use when calculating the Confidence Interval.

#### Solution

1. 30.4; 25; σxσx size 12{σ rSub { size 8{x} } } {}
2. the age of Winter 2006 Foothill students
3. μμ size 12{μ} {}
4. yes
5. Normal

## Explaining the Confidence Interval

### Exercise 2

Construct a 95% Confidence Interval for the true average age of Winter 2006 Foothill College students.

1. How much area is in both tails (combined)? α=α= size 12{α={}} {} __________
2. How much area is in each tail? α2=α2= size 12{ { {α} over {2} } ={}} {}__________
3. lower limit = ________ upper limit = ________ error bound = ________
4. The 95% Confidence Interval is: _____________________
5. Fill in the blanks on the graph with the areas, upper and lower limits of the Confidence Interval, and the sample mean.
6. In one complete sentence, explain what the interval means.

#### Solution

1. 0.05
2. 0.025
3. 24.52; 36.28; 5.88
4. (24,52,36.28)(24,52,36.28) size 12{ $$"24","52","36" "." "28"$$ } {}

## Discussion Questions

### Exercise 3

Using the same mean, standard deviation and level of confidence, suppose that nn size 12{n} {} were 69 instead of 25. Would the error bound become larger or smaller? How do you know?

### Exercise 4

Using the same mean, standard deviation and sample size, how would the error bound change if the confidence level were reduced to 90%? Why?

## Content actions

### Give feedback:

My Favorites (?)

'My Favorites' is a special kind of lens which you can use to bookmark modules and collections. 'My Favorites' can only be seen by you, and collections saved in 'My Favorites' can remember the last module you were on. You need an account to use 'My Favorites'.

| A lens I own (?)

#### Definition of a lens

##### Lenses

A lens is a custom view of the content in the repository. You can think of it as a fancy kind of list that will let you see content through the eyes of organizations and people you trust.

##### What is in a lens?

Lens makers point to materials (modules and collections), creating a guide that includes their own comments and descriptive tags about the content.

##### Who can create a lens?

Any individual member, a community, or a respected organization.

##### What are tags?

Tags are descriptors added by lens makers to help label content, attaching a vocabulary that is meaningful in the context of the lens.

| External bookmarks