text:
# Antiderivative of 1/x

1. Nov 4, 2015

### Cosmophile

We are going over antiderivatives in my calculus course and reached a question regarding $f(x) = \frac {1}{x}$.

My instructor went on to say that $\int \frac {1}{x}dx = \ln |x| + C$. This makes sense to me, but only to a certain point. For $f(x) = \frac {1}{x}$, $f$ is defined $\forall x \neq 0$. So we should have two interavls which we are looking at: $x < 0$ and $x > 0$. Because of this, we would then have:

$$\int \frac {1}{x}dx = \ln |x| + C_1 \qquad x > 0$$
$$\text {and}$$
$$\int \frac {1}{x}dx = \ln (-x) + C_2 = \ln |x| + C_2 \qquad x < 0$$

The second integral comes into being because $-x > 0$ when $x<0$. I brought this up to my teacher and he said that it made no sense and served no purpose to look at it this way. The argument I brought up was that the constants of integration could be different for the two intervals. I was hoping some of you may be able to help me explain why this is the case, or, if I am wrong, explain to me why I am.

Thanks!

2. Nov 4, 2015

### pwsnafu

You are correct. The "constant of integration" is constant over connected components of the domain. See also Wikipedia's article on antiderivative.

3. Nov 4, 2015

### fzero

It's an interesting idea, but the problem is that
$$\frac{d}{dx} \ln (-x) = - \frac{1}{x},$$
instead of $1/x$, so this isn't an antiderivative.

4. Nov 4, 2015

### pwsnafu

No $\frac{d}{dx} \ln(-x) = \frac{1}{x}$

5. Nov 4, 2015

### Cosmophile

If we are considering $x < 0$, $-x > 0$ so
$$\frac {d}{dx} \ln (-x) = \frac {1}{x}$$

Also, by the chain rule where $u = -x$, $\frac {du}{dx} = -1$, and

$$\frac {d}{dx} \ln(-x) = \frac {1}{-x}(-1) = \frac {1}{x}$$

6. Nov 4, 2015

### micromass

You are completely correct. There are two different constants of integration. Your teacher must not be very good if he doesn't know this.

7. Nov 4, 2015

### pwsnafu

Seconded. This
worries me. Mathematics is not concerned with with whether something "serves a purpose". There is plenty of mathematical research that serves no purpose other than itself.

8. Nov 4, 2015

### Cosmophile

I appreciate the replies thus far. I suppose I'm having a hard time developing an argument for my case to propose to him.

9. Nov 4, 2015

### PeroK

Essentially, you are correct. You can demonstrate this by taking:

$f(x) = ln|x| + 1 \ (x < 0)$ and $f(x) = ln|x| + 2 \ (x > 0)$ and checking that $f'(x) = \frac{1}{x} \ (x \ne 0)$

Usually, however, you are only dealing with one half of the function : $x < 0$ or $x > 0$. This is because an integral is defined for a function defined on an interval. For the function $\frac{1}{x}$, you can't integrate it from on, say, $[-1, 1]$ because it's not defined at $x = 0$.

So, strictly speaking, what the integration tables are saying is:

a) For the function $\frac{1}{x}$ defined on the interval $(0, +\infty)$, the antiderivative is $ln|x| + C$

b) For the function $\frac{1}{x}$ defined on the interval $(-\infty, 0)$, the antiderivative is $ln|x| + C$

In that sense, you don't need different constants of integration.

10. Nov 4, 2015

### micromass

I see no reason not to define the undefined integral on more general sets.

11. Nov 4, 2015

### Cosmophile

Why did you arbitrarily chose $C_1 = 1$ and $C_2 = 2$ in the first part of your response?

I understand that the antiderivative is defined only on intervals where the base function is defined, which means our integral is only defined on $(-\infty, 0) \cup (0, \infty)$. However, when I think of a constant added to a function, I simply think of a vertical shift. I understand that $f(x) = \frac {1}{x}$ has to have two independent antiderivatives as a consequence of the discontinuity, but I cannot see why it is necessary that the constants have to be different. Of course, a difference in constants is the only way that the two sides can be different, because we've already shown that, ignoring the added constant, the two sides have identical antiderivatives.

Am I making any sense? Sorry, and thanks again.

12. Nov 4, 2015

### PeroK

Why not?

A couple of technical points:

1)"The" antiderivative is actually an equivalence class of functions. "An" antiderivative is one of the functions from that class. For example:

$sin(x) + C$ (where $C$ is an arbitrary constant) is the antiderivative of $cos(x)$; and $sin(x) + 6$ is an antiderivative (one particular function from the antiderivative class).

2) There is no such thing as "the" function $1/x$, as a function depends on its domain. $1/x$ defined on $(0, \infty)$, $1/x$ defined on $(-\infty, 0)$ and $1/x$ defined on $(0, \infty) \cup (-\infty, 0)$ are three different functions.

The antiderivative of $1/x$ defined on $(0, \infty) \cup (-\infty, 0)$ is $ln|x| + C_1 \ (x < 0)$; $ln|x| + C_2 \ (x > 0)$. Where $C_1$ and $C_2$ are arbitrary constants. This is the full class of functions which, when differentiated, give $1/x$.

The two separate functions $1/x$ defined on $(0, \infty)$, and $(-\infty, 0)$ both have the antiderivate $ln|x| + C$, where $C$ is an arbitrary constant, defined on the appropriate interval.

There is, therefore, a subtle difference.

13. Nov 4, 2015

### HallsofIvy

Look at f(x)= ln(|x|)+ 9 for x> 0 and ln(|x|)+ 4 for x< 0. That function is differentiable for all non-zero x and its derivative is 1/x.

14. Nov 4, 2015

### Cosmophile

Your second point was very well said, and is certainly something I'll carry with me. So unless a particular domain is specified, such as $(0, \infty)$, I have to include the $\ln|x| +C_1 \quad (x < 0); \quad \ln |x| + C_2 \quad (x > 0)$.

I suppose my issue is coming from the fact that, when I see $f(x) = \frac {1}{x}$, I imagine the standard hyperbola $f(x) = \frac {1}{x}$ defined on $(- \infty, 0) \cup (0, \infty)$. Now, when I imagine the function $f(x) = \ln x$, I think automatically of this graph:

http://www.wolframalpha.com/share/img?i=d41d8cd98f00b204e9800998ecf8427eq1tuvuvmvh&f=HBQTQYZYGY4TMNJQMQ2WEZTBGUYDCNJQMQ3DAODGGAZTAMBQGI4Qaaaa But I've also seen this graph:

Which should I be thinking of for this problem?

Last edited: Nov 5, 2015
15. Nov 4, 2015

### Staff: Mentor

The second graph looks like it is probably f(x) = ln|x|.

16. Nov 5, 2015

### Cosmophile

You're right. I wonder why Wolfram interprets it that way, but only uses the right-hand side of the graph when I set it to show real values.

17. Nov 5, 2015

### Staff: Mentor

What was the equation you graphed? If you entered the integral in post #1 of this thread, the antiderivative is ln|x| (plus the constant).

18. Nov 5, 2015

### Cosmophile

I graphed $f(x) = \frac {1}{x}$ and got the funky results. Graphing ln|x| gave me what I needed. But if I'm given $f(x) = \frac {1}{x}$, with no specification of the domain, I end up with $F(x) = \ln |x| + C_1, \quad (x < 0); \ln|x| + C_2, \quad (x > 0).$

What's weird is that when I look at the graph of ln|x|, the two halfs seem connected (obviously, they aren't - there's a discontinuity at $x=0$), so it's hard for me to imagine why the two sides need different constants of integration. That would mean the two bits move around independently, and I can't at all think of an example of that if $f(x) = \frac {1}{x}$ with nothing else added.

I hope that makes some sense. I'd love to get some graphical insights - I think that would help me out a bit. Sorry for asking so much on what seems to be a fairly simple topic!

(Also, thanks for chiming in, Mark44. I can always count on you and Micromass to respond).

19. Nov 5, 2015

### PeroK

I suggest that you are getting yourself a bit confused over this. And, I guess this is why your maths instructor is saying it's not useful. There is nothing special about $1/x$. Any function $1/x^n$ has the same issue. Wolfram Alpha, for example, doesn't get into this subtlety of having different constants of integration. The same with tan(x) - you could have a different constant of integration on each interval upon which it's defined.

The key point is this. Suppose I have a differential equation:

$f'(x) = x^2$ and $f(1) = 0$ $(-\infty < x < \infty)$

This specifies a unique function: $f(x) = \frac{1}{3}(x^3 - 1)$

But, if we have:

$f'(x) = 1/x$ and $f(1) = 0$ $(x \ne 0)$

This does not specify a unique function. We also need a value for some $x < 0$. For example:

$f'(x) = 1/x$, $f(1) = 0$ $f(-1) = 1$ $(x \ne 0)$

The differential equation, therefore, splits into two:

For $x > 0$ we have $f(x) = ln|x| + C$, $f(1) = C = 0$, hence $f(x) = ln|x| (x > 0)$

For $x < 0$ we have $f(x) = ln|x| + C$, $f(-1) = C = 1$, hence $f(x) = ln|x| + 1 (x < 0)$

Now, of course, you could use $C_1$ and $C_2$ instead of reusing the symbol $C$ as I have done. But, it hardly matters. The important point is that the integration and differentiation for a function like $1/x$ must be done separately on each contiguous interval on which it's defined.

One final point. You can have the same situation with any function. Suppose we have:

$f'(x) = x \ (-2 < x < -1$ and $1 < x < 2)$

Then we are specifying a differential equation across two discontiguous intervals, hence we need two initial values, as there is a different constant of integration on each interval.

20. Nov 5, 2015

### micromass

About the wolfram issue. Wolfram alpha is a very good software but not infallible. In particular, here it is (strictly speaking) wrong.

When asked how to integrate $1/x$, wofram alpha somehow involves complex numbers. Furthermore, it will only show one particular primitive.
So when you ask for the primitive of $1/x$, wolfram accurately calculates the following primitive: $f(x) = \text{ln}(x)$ for $x>0$ and $f(x) = \text{ln}(x) + \pi i$ for $x<0$. (The explanation for why $\pi i$ is involved requires complex analysis). Anyway, this is a correct primitive as you can differentiate it to get $1/x$. Wolfram alpha is wrong however to say that any other primitive is of the form $f(x) + C$. Rather, it is of the form $f(x) + C_1$ for $x>0$ and $f(x) + C_2$ for $x<0$. In particular, we can choose $C_1 = 0$ and $C_2 = -\pi i$, to get $\text{ln}|x|$.
So if you want only the real values, then wolframalpha works with the same primitive $f$ that has already been computed. But this primitive is complex for $x<0$ and thus wolfram ignores it. So that is why it only shows $f(x)$ for $x>0$. There is a primitive that takes only real values (namely $\text{ln}|x|$), but wolfram does not compute it and erroneously states that the real primitive only exists for $x>0$.


text:
9k views

### Ultrafilters and automorphisms of the complex field

It is well-known that it is consistent with $ZF$ that the only automorphisms of the complex field $\mathbb{C}$ are the identity map and complex conjugation. For example, we have that ...
4k views

### Dropping three bodies

Consider the usual three-body problem with Newtonian $1/r^2$ force between masses. Let the three masses start off at rest, and not collinear. Then they will become collinear a finite time ...

format: plain


text:
# Tag Info

7

Welcome to AI.SE @Kate_Catelena! I teach AI courses at the undergraduate level, and so have seen a lot of semester projects over the years. Here are some templates that often lead to exciting outcomes: Pick a new board or card game, and write a program to play it. Your course has probably covered Adversarial Search, and may also have covered Monte Carlo ...

2

Here are some possible options Music Generation using GA/MA Open AI's gym projects 2048 on RL and search algorithms Fixing bugs in the source code of some AI software project

2

Given that the neurons are linear in the hidden layer of the neural network, so the output is just the dot product of the weights and the input. To put things in perspective, generally, we use an activation function (sigmoid, signum, etc.), which is applied to the dot product. Hence, for an input of $3$ inputs to node 1 of hidden layer is $-3 * 3 = -9$, to ...

1

The loss function (aka cost function) measures the correctness of the predictions of the model. For example, a simple cost function could be $|y - f(x)|$, where $\hat{y} = f(x)$ is the prediction of the model $f$ when the input is $x$, $y$ is the ground-truth label for input $x$ (i.e. what the model is supposed to output when the input is $x$), and \$|\...

1

This question really looks like a homework problem, in part because it is too vague (what does it mean to 'get stuck' exactly?). Hill climbing stops when it reaches a local maximum. Hill climbing is an uninformed search algorithm, so it does not make use of a heuristic. Hill climbing may or may not stop on a ridge, depending on the implementation. Some ...

1

Initial state: initial position of the monkey. Possible actions climb on the crate, get down the crate, move the crate from one spot to another, stack one crate on another, walk from one spot to another, grab bananas (if standing on the crate) Goal test: did the monkey get the bananas? Cost function: the number of actions completed

Only top voted, non community-wiki answers of a minimum length are eligible


text:
For historical reasons, JavaScript files are AMD modules in TAO. TAO uses AMD and require.js :

• to define import and export, and declare dependencies
• as a dependency injection library
• as a dependency resolver (for bundling)

All modules have the same form :

define([                            //you define a module
'lodash',                       //declare the dependencies, here an alias
'taoQtiItem/component/foo'      //here the resolved module name
], function(_, fooComponent){       //and use the exported values by the dependencies
'use strict';                   //ES5 so enforce the strict

return {                        //The module exports something
bar : true
}
});

Even without dependencies, a module needs to be wrapped into a define statement.

## Module paths

The dependencies are declared using a module name, which is not necessarily a path. By default you can make the reference to a module by using the following pattern: ${extensionName}/${pathInViews}/${moduleName}. For example to access taoQtiTest/views/js/runner/plugins/control/timers/timer.js you'll use taoQtiTest/runner/plugins/control/timers/timer. You'll notice the views/js disappear as well as the file extension. The base URL is always for JavaScript resources tao/views/js so for modules into the tao extension you don't need to prefix them with tao. For example to access tao/views/js/core/eventifier.js, core/eventifier should be used. Modules with an alias defined in the configuration can be called using this defined alias such as lodash, jquery, moment, i18n, etc. Since alias create some coupling between the source code and the configuration, we try to reduce their usage as much as possible. ## Named modules Named modules are prohibited. define( 'bar', [ 'lodash', 'taoQtiItem/component/foo' ], function(_, fooComponent){ 'use strict'; return { bar : true } }); They won't work once optimized Some libraries still use named modules, to support this heresy we have to define an alias in the configuration. ## Dependency injection The content of the callback function is executed the first time it is required by another module and the main scope lifecycle will remain until the page refresh. Let's define a module : define([], function(){ 'use strict'; var foo = 0; return { getFoo: function getFoo(){ return ++foo; } }; }); If you require this module in a module A, and call getFoo then after in another module B, you also call getFoo, you'll get the value 2, etc. ## Configuration ## Runtime configuration The main configuration is created by a dynamic service, through the URL /tao/ClientConfig/config which generates the require.js configuration. The configuration options can be modified through the template and the controller linked to that route : • tao/actions/class.ClientConfig.php • tao/views/templates/client_config.tpl ### Test and build configuration A static and lighter version of the configuration is located at tao/views/build/config/requirejs.build.json. It needs to be updated manually. ### Module configuration It's possible to give a configuration to a dedicated module. This can be done by modifying the configuration itself or by using the dedicated registry oat\tao\model\ClientLibConfigRegistry (a PHP helper that register configuration for a given module). It creates an entry into the file config/tao/client_lib-config_registry.conf.php that will be used to configure a client side module. From the JavaScript file, the configuration will be available through the module module. ### Example The module util/locale needs a configuration from the server, the date time format. In the install/update scripts, the ClientLibConfigRegistry is called in order to register the configuration : oat\tao\model\ClientLibConfigRegistry::getRegistry()->register( 'util/locale', ['dateTimeFormat' => 'DD/MM/YYYY HH:mm:ss'] ); The first argument of the register is obviously the name of the AMD module you want to configure. To access this configuration the module util/locale will use the module module : define([ 'lodash', 'module' // the special dependency : module ], function(_, module) { var configuration = module.config(); console.log(configuration.dateTimeFormat); // will contain 'DD/MM/YYYY HH:mm:ss' }); More information on this topic can be found at https://requirejs.org/docs/api.html#config-moduleconfig. ### Getting data from the server There are multiple ways to get data from the server : • Using the module configuration (see above) : • Using HTTP requests • Using the DOM In order to get data from the server, you will use the configuration only for system configuration and HTTP requests for anything else. All other ways should be avoided as much as possible. You will see in the source code, dynamic reconfiguration of modules. This is an anti-pattern and should be removed.  ### Loading Templates TAO supports loading templates as AMD dependencies. • Templates are formatted using the Handlebars syntax (see https://handlebarsjs.com) • The template file extension is .tpl • They must be loaded through AMD, using 'tpl!path/to/module' (WITHOUT the .tpl extension, since a template is considered as a JavaScript file) • Templates are compiled into JavaScript function during the build • The exported value is a function For example, consider the file tao/views/js/ui/switch/tpl/switch.tpl :
 <input type="checkbox" name="{{name}}" {{#if on.active}}checked{{/if}}>  {{off.label}} {{on.label}}
 Then you can load it in a module using the tpl! loader (you'll notice the file extension .tpl is missing) : define([ 'tpl!ui/switch/tpl/switch' ], function(switchTemplate){ 'use strict'; //this variable will contain astring var switchHTML = switchTemplate({ name : 'light', on : { active: true, label : 'On' } }); }); ### Loading JSON data TAO supports loading JSON files as AMD dependencies, using 'json!path/to/module.json' (WITH the .json extension). The result is directly parsed to a JavaScript Object For example, consider the file tao/views/js/core/mimetype/categories.json : { "video" : { "category" : "media", "mimes" : ["application/ogg", "video/*"], "extensions" : ["avi", "mp4", "ogg", "mpeg", "flv"] }, "audio" : { "category" : "media", "mimes" : ["audio/*"], "extensions" : ["mp3", "wav", "aac"] }, //... } Then you can load it into a module using the json! loader (you'll notice the file extension is there) : define([ 'json!core/mimetype/categories.json' ], function(mimeTypeCategories){ 'use strict'; var audioExtensions = mimeTypeCategories.audio.extensions; }); ### Loading stylesheets TAO supports loading CSS files as AMD dependencies, using 'css!path/to/module.json' (WITH the .css extension). • The stylesheet is loaded when the module is loaded for the first time. • Stylesheets doesn't export anything, so by convention, add them at the end of your dependencies For example, consider the file tao/views/js/ui/switch/css/switch.css, to include in a JavaScript module : define([ 'css!ui/switch/css/switch.css' ], function(){ 'use strict'; }); ### Bundling Client side source code must be optimized There are two distinct modes into TAO : 1. DEBUG mode (aka Development mode) 2. PRODUCTION mode (aka Bundle mode) You can change the mode by switching the value of the constant DEBUG_MODE into config/generis.conf.php The main difference between those two modes is the client side source code is optimized. Per extension, the source code is aggregated into bundles, transformed and optimized : The bundler is available as a Grunt task in the repository oat-sa/grunt-tao-bundle. • The bundler create bundles per extension and per target (backoffice, frontoffice, separate entry point, etc.) • Libraries and the core framework are in a vendor bundle • The optimizer supports UglifyJs and Babel • Each extension needs to configure its bundles into the files views/build/grunt/bundle.js • Bundling is done during the release of an extension, not during it's development. For example : module.exports = function(grunt) { //it's a Grunt configuration so we're in a node.js process 'use strict'; grunt.config.merge({ //add it to the configuration bundle : { //the config entry is always bundle taoce : { //name the task like the extension, lowercase, by convention options : { //define the bundles options extension : 'taoCe', outputDir : 'loader', bundles : [{ name : 'taoCe', default : true, babel : true //babel is used to transpile the code }] } } } }); grunt.registerTask('taocebundle', ['bundle:taoce']); //register a task alias }; Per extension you can generate the bundle using the following command, the task name is ${extensionNameLowerCase}bundle, so to bundle the extension taoCe you'll run :

The TAO application can be seen has multiple Single Page Application (because of the transition of multiple pages to SPA). Each page, which is the result of a navigation or a dedicated entry point contains the loader.

The loader can take two appearances :

1. In development (or DEBUG_MODE) :

The loader loader require.js, a bootstrap that will load the config and the given controller (based on the values from the data-attr). Each module is loaded separately (the source files are loaded one by one) and only when requested.

></script>


text:
# How old is [vintage]?

I recently noticed the tag. The tag wiki simply specifies, "Used for old vintage LEGO sets and pieces."

How old is old enough for a set or piece to qualify as "vintage"? For example, would Paradisa and Blacktron be considered vintage? 4.5 volt trains? Classic Space (mid-1980's)? Fabuland? The Yellow Castle? Only stuff from before 1970? Only the very early years?

My personal opinion would be that anything before my "dark age" (circa 1995) feels vintage, but I recognize that many people will have a different perspective. Is there anything approaching a consensus on what is and what is not vintage?

I'm not really asking for an exhaustive or scientific answer, and don't need an adjudication on a borderline case. What I want to avoid is, say, tagging a bunch of monorail questions as vintage and then getting stern messages that vintage means pre-1980 and not just discontinued.

Looking at the questions we currently have tagged it does seem to imply "early 80s" at the latest - however as with cars and furniture, this is likely to be a moving target: would you consider the pre-realistic skin tone licensed sets as "Vintage LEGO Star Wars" for example, or just "Classic"?

For me personally, vintage seem to be pre-1995 too (as this is where I got into Dark Age). This was 25 years ago, which is quite some time ago.

However I could think of a good point of time in LEGO history which could be considered a turning point here - change of Light/Dark Gray [BL] to Light/Dark Bluish Gray [BL] (and few other colors). It wasn't just a color change, but also quite drastical change in set designing approach as well as designers themselves.

To second Alex's timeframe, the urban dictionary definition for vintage states:

An item of age, usually from around the 1920's to [approximately] 20 years ago. The items could be anything from furniture, children's toys, to clothing and household bits and pieces.

So that'd be anything before 2000 at this point. I wish Zhaph's answer was closer to the usage I'd heard, but it seems like I'm going to go feel old for a while now.

• If we had to pick an arbitrary cutoff I think 20 years ago is reasonable. – qwr Aug 18 '20 at 0:31


text:
# Help me understand how DirectX treats the W component

## Recommended Posts

jdub    459

I have these simple shaders to draw a triangle:

cbuffer viewBuffer
{
matrix view;
};

struct VS_INPUT
{
float4 Position : POSITION;
};

struct PS_INPUT
{
float4 Position : SV_POSITION;
};

{
PS_INPUT output;
output.Position = float4(input.Position.x, input.Position.y, 0.5f, 1.0f);

return output;
}

{
return float4(1.0f, 1.0f, 1.0f, 1.0f);
}

The triangle draws fine with these parameters.  However, if I change the W component of the Position for the output of the Vertex shader, the triangle doesn't draw at all.  I understand that having a 4 component vector is useful for calculating transformations using 4x4 matrices.  However, I don't really understand why changing W is causing my triangle to not draw here.

##### Share on other sites

The x, y and z coordinates end up getting divided by the w component.

What are you changing the w component to? 0.0 would not be good. Other values should scale the x, y and z in world space possibly moving the triangle off screen or beyond the clip planes.

##### Share on other sites

When transforming vectors by matrices the w component has the effect of scaling the translational component of your matrix.  Consider the vanilla transformation matrix encountered while doing graphics work:

| ux vx nx tx|  |x|   |(x y z) dot (ux uy uz) + tx*w|
| uy vy ny ty|* |y| = |(x y z) dot (vx vy vz) + ty*w|
| uz vz nz tz|  |z|   |(x y z) dot (nx ny nz) + tz*w|
|  0  0  0  1|  |w|   |                            w|

?

?

?

?

?

The rotation and scale of the matrix is stored in the u, v, and n vectors and the translational component is stored in the t vector.  As you can in the right-hand-side the (x y z) components of the original vector where translated by w*t.  For directions w is set to 0 (or implicitly interpreted as 0) since translations are irrelevant to directions.  For points w is set to 1 (or implicitly interpreted as 1) treating the translation as expected.

Now for the good stuff.  Consider multiplying a point by a projection matrix:

| sx  0  0  0| |x|   |x*sx     |
|  0 sy  0  0|*|y| = |y*sy     |
|  0  0 sz tz| |z|   |z*sz + tz|
|  0  0  1  1| |1|   |z        |

The right-hand-side is the data spit out by your vertex shader.  For various mathematical reasons that I won't get into the GPU will clip data against the view frustum in this space and it is thus called clip space.  To apply perspective some magic happens, the right-hand-side gets homogenized or divide by its w component:

H( |x*sx   | ) = | (sx*x)    / z |
|y*sy   |     | (sy*y)    / z |
|z*sz+tz|     | (sz*z+tz) / z |
|z      |     | 1             |

From here the right-hand-side is said to be in NDC or normalized device coordinates.  The z component gets directly written to the depth buffer, the x and y component are scaled and biased to generate pixel coordinates and the w component is simply discarded (it will always be 1).

If you are hand setting the w value of your vertex in the vertex shader you must take into account that the GPU will divide (x, y, z) by w to generate NDC coordinates.

 I don't know what all that whitespace is...I can't get rid of it

Edited by nonoptimalrobot

##### Share on other sites
jdub    459

Thanks for the responses guys! I really appreciate it


text:
This content will become publicly available on April 1, 2023

Damped Lyα Absorbers in Star-forming Galaxies at z < 0.15 Detected with the Hubble Space Telescope and Implications for Galactic Evolution
Abstract We report Hubble Space Telescope Cosmic Origins Spectrograph spectroscopy of 10 quasars with foreground star-forming galaxies at 0.02 < z < 0.14 within impact parameters of ∼1–7 kpc. We detect damped/sub-damped Ly α (DLA/sub-DLA) absorption in 100% of cases where no higher-redshift Lyman-limit systems extinguish the flux at the expected wavelength of Ly α absorption, obtaining the largest targeted sample of DLA/sub-DLAs in low-redshift galaxies. We present absorption measurements of neutral hydrogen and metals. Additionally, we present Green Bank Telescope 21 cm emission measurements for five of the galaxies (including two detections). Combining our sample with the literature, we construct a sample of 117 galaxies associated with DLA/sub-DLAs spanning 0 < z < 4.4, and examine trends between gas and stellar properties, and with redshift. The H i column density is anticorrelated with impact parameter and stellar mass. More massive galaxies appear to have gas-rich regions out to larger distances. The specific star formation rate (sSFR) of absorbing galaxies increases with redshift and decreases with M *, consistent with evolution of the star formation main sequence (SFMS). However, ∼20% of absorbing galaxies lie below the SFMS, indicating that some DLA/sub-DLAs trace galaxies with longer-than-typical gas-depletion timescales. Most DLA/sub-DLA galaxies more »
Authors:
; ; ; ; ; ;
Award ID(s):
Publication Date:
NSF-PAR ID:
10351667
Journal Name:
The Astrophysical Journal
Volume:
929
Issue:
2
Page Range or eLocation-ID:
150
ISSN:
0004-637X
National Science Foundation
##### More Like this
1. Abstract

We present the discovery of neutral gas detected in both damped Lyαabsorption (DLA) and Hi21 cm emission outside of the stellar body of a galaxy, the first such detection in the literature. A joint analysis between the Cosmic Ultraviolet Baryon Survey and the MeerKAT Absorption Line Survey reveals an Hibridge connecting two interacting dwarf galaxies (log (Mstar/M) = 8.5 ± 0.2) that host az= 0.026 DLA with log[N(Hi)/cm−2] = 20.60 ± 0.05 toward the QSO J2339−5523 (zQSO= 1.35). At impact parameters ofd= 6 and 33 kpc, the dwarf galaxies have no companions more luminous than ≈0.05L*within at least Δv= ±300 km s−1andd≈ 350 kpc. The Hi21 cm emission is spatially coincident with the DLA at the 2σ–3σlevel per spectral channel over several adjacent beams. However, Hi21 cm absorption is not detected against the radio-bright QSO; if the background UV and radio sources are spatially aligned, the gas is either warm or clumpy (with a spin temperature to covering factor ratioTs/fc> 1880 K). Observations with VLT-MUSE demonstrate that theα-element abundance of the ionized interstellar medium (ISM) is consistent with the DLA (≈10% solar), suggesting that the neutral gas envelope is perturbed ISM gas. This study showcases the impact of dwarf–dwarfmore »

2. Abstract

We report a NOrthern Extended Millimeter Array (NOEMA) and Atacama Large Millimeter/submillimeter Array search for redshifted CO emission from the galaxies associated with seven high-metallicity ([M/H] ≥ −1.03) damped Lyαabsorbers (DLAs) atz≈ 1.64–2.51. Our observations yielded one new detection of CO(3–2) emission from a galaxy atz= 2.4604 using NOEMA, associated with thez= 2.4628 DLA toward QSO B0201+365. Including previous searches, our search results in detection rates of CO emission of$≈56−24+38$% and$≈11−9+26$%, respectively, in the fields of DLAs with [M/H] > −0.3 and [M/H] < −0.3. Further, the Hi–selected galaxies associated with five DLAs with [M/H] > −0.3 all have high molecular gas masses, ≳5 × 1010M. This indicates that the highest-metallicity DLAs atz≈ 2 are associated with the most massive galaxies. The newly identifiedz≈ 2.4604 Hi–selected galaxy, DLA0201+365g, has an impact parameter of ≈7 kpc to the QSO sightline, and an implied molecular gas mass of (5.04 ± 0.78) × 1010× (αCO/4.36) × (r31/0.55)M. Archival Hubble Space Telescope Wide Field and Planetary Camera 2 imaging covering the rest-frame near-ultraviolet (NUV) and far-ultraviolet (FUV) emission from this galaxy yield nondetections of rest-frame NUV and FUV emission, and a 5σupper limit of 2.3Myr−1on the unobscuredmore »

3. ABSTRACT

We examine the properties of damped Lyman-α absorbers (DLAs) emerging from a single set of cosmological initial conditions in two state-of-the-art cosmological hydrodynamic simulations: simba and technicolor dawn. The former includes star formation and black hole feedback treatments that yield a good match with low-redshift galaxy properties, while the latter uses multifrequency radiative transfer to model an inhomogeneous ultraviolet background (UVB) self-consistently and is calibrated to match the Thomson scattering optical depth, UVB amplitude, and Ly α forest mean transmission at z > 5. Both simulations are in reasonable agreement with the measured stellar mass and star formation rate functions at z ≥ 3, and both reproduce the observed neutral hydrogen cosmological mass density, $\Omega _{\rm H\, \small{I}}(z)$. However, the DLA abundance and metallicity distribution are sensitive to the galactic outflows’ feedback and the UVB amplitude. Adopting a strong UVB and/or slow outflows underproduces the observed DLA abundance, but yields broad agreement with the observed DLA metallicity distribution. By contrast, faster outflows eject metals to larger distances, yielding more metal-rich DLAs whose observational selection may be more sensitive to dust bias. The DLA metallicity distribution in models adopting an H2-regulated star formation recipe includes a tail extending to [M/H] ≪ −3, lower than anymore »

4. Abstract The H i gas content is a key ingredient in galaxy evolution, the study of which has been limited to moderate cosmological distances for individual galaxies due to the weakness of the hyperfine H i 21 cm transition. Here we present a new approach that allows us to infer the H i gas mass M HI of individual galaxies up to z ≈ 6, based on a direct measurement of the [C ii ]-to-H i conversion factor in star-forming galaxies at z ≳ 2 using γ -ray burst afterglows. By compiling recent [C ii ]-158 μ m emission line measurements we quantify the evolution of the H i content in galaxies through cosmic time. We find that M HI starts to exceed the stellar mass M ⋆ at z ≳ 1, and increases as a function of redshift. The H i fraction of the total baryonic mass increases from around 20% at z = 0 to about 60% at z ∼ 6. We further uncover a universal relation between the H i gas fraction M HI / M ⋆ and the gas-phase metallicity, which seems to hold from z ≈ 6 to z = 0. The majority of galaxiesmore »
5. ABSTRACT Recent searches for the hosts of z ∼ 4 damped Ly α absorbers (DLAs) have detected bright galaxies at distances of tens of kpc from the DLA. Using the FIRE-2 cosmological zoom simulations, we argue that these relatively large distances are due to a predominantly cool and neutral inner circumgalactic medium (CGM) surrounding high-redshift galaxies. The inner CGM is cool because of the short cooling time of hot gas in ${\lesssim}10^{12}\, {\rm M_{\odot }}$ haloes, which implies that accretion and feedback energy are radiated quickly, while it is neutral due to high volume densities and column densities at high redshift that shield cool gas from photoionization. Our analysis predicts large DLA covering factors (${\gtrsim}50{{\ \rm per\ cent}}$) out to impact parameters ∼0.3[(1 + z)/5]3/2Rvir from the central galaxies at z ≳ 1, equivalent to a proper distance of ${\sim}21\, M_{12}^{1/3} \left(\left(1+z\right)/5\right)^{1/2}\, {\rm kpc}$ (Rvir and M12 are the halo virial radius and mass in units of $10^{12}\, {\rm M_{\odot }}$, respectively). This implies that DLA covering factors at z ∼ 4 may be comparable to unity out to a distance ∼10 times larger than stellar half-mass radii. A predominantly neutral inner CGM in the early universe suggests that its mass andmore »


text:
## Schedule

For Spring 2018, the Theory Seminar will meet on Fridays from 2:00-3:00pm in GDC 4.302 unless otherwise noted. This schedule is being updated throughout the semester.

1/12/2018 – Keerti Choudhary, Weizmann Institute: “Fault Tolerant Structures for Reachability and Strong-connectivity”
1/19/2018 – Ryan Williams, MIT: "Circuit Lower Bounds for Nondeterministic Quasi-Polytime"
2/02/2018 – Adam Klivans, University of Texas at Austin: "Learning Discrete Markov Random Fields with Nearly Optimal Runtime and Sample Complexity"
2/09/2018 – Chandra Chekuri, University of Illinois: "Speeding up MWU Based Approximation Schemes for Positive LPs and Some Applications"
2/16/2018 – Avishay Tal, Stanford University: "Improved Pseudorandomness for Unordered Branching Programs through Local Monotonicity"
3/02/2018 – Alexandros Dimakis, University of Texas at Austin: "Generative Models and Compressed Sensing"
3/23/2018 – Li-Yang Tan, TTI-Chicago: "Fooling Polytopes"
3/30/2018 – Seth Pettie, University of Michigan: "A Time Hierarchy Theorem for the LOCAL Model"
4/13/2018 – Prashant Nalini Vasudevan, MIT: "Fine-Grained Cryptography"
4/20/2018 – Joseph Neeman, University of Texas at Austin: "Learning and Testing Linear Juntas"
4/27/2018 – Toni Pitassi, University of Toronto: "Lifting in Communication Complexity, and Applications"
5/04/2018 – Michael Saks, Rutgers University: "Lower Bounds for Online Labeling"
5/11/2018 – Jason D. Lee, USC: "Geometry of Optimization Landscapes and Implicit Regularization of Optimization Algorithms"

1/12/2018
Keerti Choudhary, Weizmann Institute:
Fault Tolerant Structures for Reachability and Strong-Connectivity

In this talk, we look at the problems of single-source-reachability (SSR) and strongly-connected-components (SCC) in presence of failures of vertices and edges. In the static setting, these problems can be solved in O(|V|+|E|) time, for any directed graph G=(V, E). To model the scenario of a faulty network, we associate a parameter k with the network such that there are at most k vertices (or edges) that are failed at any stage. The goal is to preprocess the graph G and compute a compact data structure, that, given any set F of at most k vertices (or edges), efficiently solves the SSR and SCC problems for the graph G\F.

We show that, given a directed graph G with n vertices, and a positive integer k, we can obtain a fault tolerant data structure that solves the SSR and SCC problems for G\F in O(2^k n polylog n) time for any set F of size at most k. For the problem of SSR, we show a much stronger result, i.e., for every positive integer k, there is a subgraph (sparse certificate) H of G with at most (2^k n) edges such that vertices reachable from source in G\F and H\F are identical, for every F of size at most k. Our results makes an interesting usage of the simple techniques like max-flows, farthest min-cuts, and heavy path decomposition.

1/19/2018
Ryan Williams, MIT:
Circuit Lower Bounds for Nondeterministic Quasi-Polytime

I will give an overview of the recent proof (with my PhD student Cody Murray) that the class NQP = NTIME(n^{polylog n}) does not have ACC circuits of n^{log n} size (even with a layer of threshold gates at the bottom). This is achieved by strengthening a key component of the proof of NEXP not in ACC; in particular, we prove a new "Easy Witness Lemma" for NQP.

2/02/2018
Adam Klivans, University of Texas at Austin
Learning Discrete Markov Random Fields with Nearly Optimal Runtime and Sample Complexity

We give an algorithm for learning the structure of an undirected graphical model over any finite alphabet that has nearly optimal runtime and sample complexity.  We make no assumptions on the structure of the graph.  For Ising models, this subsumes and improves on all prior work.  For higher-order MRFs, these are the first results of their kind.

Our approach is new and uses a multiplicative-weight update algorithm.  Our algorithm-- Sparsitron-- is easy to implement (has only one parameter) and holds in the online setting. It also gives the first provably efficient solution to the problem of learning sparse Generalized Linear Models (GLMs).

Joint work with Raghu Meka

2/09/2018
Chandra Chekuri, University of Illinois:
Speeding up MWU Based Approximation Schemes for Positive LPs and Some Applications

One of the recent exciting directions in algorithms is developing faster algorithms for various problems in discrete and combinatorial optimization via sophisticated continuous optimization methods. The multiplicative weight update (MWU) method is an older technique and has been used to approximately solve positive linear programs (packing, covering and mixed packing and covering LPs) starting from the early 90s. MWU based methods have some advantages when dealing with implicit linear programs that arise frequently in combinatorial optimization. We build upon several existing ideas and propose some new ones to obtain significantly faster algorithms for several problems. The talk will illustrate some examples including Metric-TSP, spanning tree packing, and geometric packing and covering problems.

Based on joint work with Kent Quanrud.

2/16/2018
Avishay Tal, Stanford University
Improved Pseudorandomness for Unordered Branching Programs through Local Monotonicity

We present an explicit pseudorandom generator with polylog(n) seed length for read-once constant-width branching programs that can read their $n$ input bits in any order. This improves upon the work of Impagliazzo, Meka, and Zuckerman (FOCS, 2012), where they required seed length $n^{1/2+o(1)}$.

A central ingredient in our work is a bound on the Fourier spectrum of constant-width branching programs, settling a conjecture posed by Reingold, Steinke, and Vadhan (RANDOM, 2013).

Our analysis crucially uses a notion of local monotonicity on the edge labeling of the branching program. We carry critical parts of our proof under the assumption of local monotonicity and show how to deduce our results for unrestricted branching programs.

Joint work with Eshan Chattopadhyay, Pooya Hatami, and Omer Reingold

3/2/2018
Alexandros Dimakis, University of Texas at Austin
Generative Models and Compressed Sensing

The goal of compressed sensing is to estimate a vector from an underdetermined system of noisy linear measurements, by making use of prior knowledge. For most results in the literature, the structure is represented by sparsity in a well-chosen basis. We show how to achieve guarantees similar to standard compressed sensing but without employing sparsity at all. Instead, we assume that the unknown vectors lie near the range of a generative model, e.g. a GAN or a VAE. We show how the problems of image inpainting and super-resolution are special cases of our general framework.

We show how to generalize the RIP condition for generative models and that random gaussian measurement matrices have this property with high probability. A Lipschitz condition for the generative neural network is the key technical issue for our results. Time permitting we will discuss how this method can be used to protect from adversarial examples.

(Based on collaborations with Ashish Bora, Ajil Jalal and Eric Price)

3/23/2018
Li-Yang Tan, TTI-Chicago
Fooling Polytopes

We give an explicit pseudorandom generator with seed length poly(log m,1/delta) log(n) that delta-fools intersections of m halfspaces over {0,1}^n (equivalently, m-facet polytopes).  Joint work with Ryan O'Donnell (CMU) and Rocco Servedio (Columbia).

3/30/2018
Seth Pettie, University of Michigan
A Time Hierarchy Theorem for the LOCAL Model

The celebrated "Time Hierarchy Theorem" for Turing machines states, informally,
that more problems can be solved given more time.  The extent to which a time hierarchy-type theorem
holds in the classic distributed LOCAL model has been open for many years.  In particular, it is consistent
with previous results that all natural problems in the LOCAL model can be classified according
to a small constant number of complexities, such as $O(\log^* n), O(\log n), 2^{O(\sqrt{\log n})}$, etc.

We establish the first time hierarchy theorem for the LOCAL model and prove that several gaps exist in the
LOCAL time hierarchy.  One of the gap results can be interpreted as showing that the distributed Lovasz
local lemma is complete for randomized sublogarithmic time.

Joint work with Yi-Jun Chang.  Extended abstract appeared in FOCS 2017.  Full version at arXiv:1704.06297.

4/13/2018
Prashant Nalini Vasudevan, MIT
Fine-Grained Cryptography

Fine-grained cryptography is the study of cryptographic objects that are required to be secure only against adversaries that are moderately more powerful than the honest parties. This weakening in security requirements open up possibilities for meaningful cryptographic constructions in various settings using hardness assumptions that are considerably weaker than those used in standard cryptography. In this talk, I will provide a brief overview of the area and of two of our papers:

1. In the first, we construct several unconditionally secure cryptographic primitives that are computable by and secure against constant-depth circuits. Under a reasonable complexity-theoretic assumption, we do the same for log-depth circuits.

2. In the second, we present functions that are hard to compute on average for algorithms running in some fixed polynomial time, assuming widely-conjectured worst-case hardness of certain problems from the study of fine-grained complexity. We also construct a proof-of-work protocol based on this hardness and certain structural properties of our functions.

Based on joint work with Marshall Ball, Akshay Degwekar, Alon Rosen, Manuel Sabin, and Vinod Vaikuntanathan.

4/20/2018
Joseph Neeman, University of Texas at Austin
Learning and Testing Linear Juntas

Suppose you have a function on a high-dimensional space, but it is secretly just a function of some low-dimensional subspace. Such a function is called a "linear k-junta," where k is the dimension of the small subspace. I'll present a polynomial-time algorithm that evaluates a function on poly(k) points and then decides whether it is a k-junta. If it is, I'll present another algorithm that can learn the function in exp(k) queries. The important point is that for both algorithms, the query complexity doesn't depend on the ambient dimension.

4/27/2018
Toni Pitassi, University of Toronto
Lifting in Communication Complexity, and Applications

Hardness escalation is a growing research area whereby lower bounds and separations in communication complexity are obtained by developing simulation or lifting theorems. The basic idea of a lifting is to start with an arbitrary function and lift it" via function composition in order to get a new function whose communication complexity is essentially the same as the query complexity of the original function. In query complexity, the objects of study are decision trees, perhaps the simplest, most basic model of computation.  A simulation theorem thus shows that the optimal communication protocol for the composed function is essentially the trivial one which mimics the decision tree protocol.

In this talk we will review the basic lifting theorems that have been proven, and discuss their many applications, including game theory, extension complexity, proof complexity, and circuit complexity. We will pay special attention to a recent lifting theorem (joint with Robert Robere) that translates Nullstellensatz degree lower bounds to lower bounds for Gal's rank measure. This lifting theorem implies exponential monotone span program lower bounds and separations over all finite fields.

5/04/2018
Michael Saks, Rutgers University
Lower Bounds for Online Labeling

The online labeling problem (also known as the file maintenance problem), is a natural algorithmic problem that has arisen as a building block for data structures. A stream of distinct integer items is to be assigned labels online from the label set {1,....,m} so that the order of the labels strictly respects the natural order of the items.  Maintaining this order condition may require relabeling items.  The algorithm pays 1 each time an item is labeled or relabeled and the goal of the algorithm is to minimize the total cost.

I'll survey upper and lower bounds and open problems with an emphasis on recent lower bounds in both the deterministic and randomized setting.

5/11/2018
Jason D. Lee, USC
Geometry of Optimization Landscapes and Implicit Regularization of Optimization Algorithms

We first study the problem of learning a Gaussian input two-layer ReLU network with positive output layer and  and the symmetric matrix completion problem. Despite the non-convexity of both problems, we prove that every local minimizer is a global minimizer. Since gradient descent converges to local minimizers, this shows that simple gradient-based methods can find the global optimum of these non-convex problems.

In the second part, we analyze the implicit regularization effects of various optimization algorithms. In particular we prove that for least squares with mirror descent, the algorithm converges to the closest solution in terms of the bregman divergence. For linearly separable classification problems, we prove that the steepest descent with respect to a norm solves SVM with respect to the same norm. For over-parametrized non-convex problems such as matrix sensing or neural net with quadratic activation, we prove that gradient descent converges to the minimum nuclear norm solution, which allows for both meaningful optimization and generalization guarantees.


text:
# Not the squares you were looking for

• A $$5\times5$$ square has area $$\pi$$.
• A $$7\times7$$ square has area $$8$$.
• An $$8\times8$$ square has area $$0$$.
• A $$10\times10$$ square has area $$30$$ (not quite $$13$$).

Why?

The answer should be clear when you find it, and does not involve arbitrary or tenuous connections.

Can get by

Converting the letters to the answers into the alphabetic equivalent
pi 16+9 = 25 = 5x5
eight 5+9+7+8+20 = 49 = 7x7
zero 26+5+18+15 = 64 = 8x8
thirty 20+8+9+18+20+25 = 100 = 10x10
(thirteen 20+8+9+18+20+5+5+14 = 99 = nearly 100)

• Excellent! Well spotted. – Rand al'Thor Apr 2 at 13:51
• . Good puzzle! . – Lanny Strack Apr 2 at 13:54
• Funny story: this was almost a reverse-puzzling challenge. I have a text file that I use for making notes while trying to solve various puzzles; today I was clearing up some obsolete stuff from now-fully-solved puzzles, and I found something rot13(nqqvat gur yrggref va MREB naq CV gb trg fvkgl-sbhe naq gjragl-svir). Even now I don't remember why I wrote that there or what I was trying to solve then, but I noticed the squares and thought, hey, that'd make a fun new puzzle! – Rand al'Thor Apr 2 at 13:54


text:
Collecting form errors to be displayed

I have a piece of code that get errors from form and display to view:

$errors =$form->getMessages();
$msg = ''; foreach ($errors as $error) { foreach ($error as $err) {$msg .= $err . '
'; } }$this->view->error_message = $msg;  It look so ugly, but now I don't have any ideas to improve it. Thank for help. • No way to use less foreach loop and get it cleaner. – Shoe Dec 14 '11 at 17:32 • It is impossible to tell without knowing the exact structure of$errors. – Paul Dec 15 '11 at 0:56

You can use array_merge to reduce the array from 2-dim to 1-dim, then implode the array.

$this->view->error_message = implode(array_reduce($form->getMessages(),
"array_merge",
array()),
"
");

http://php.net/manual/en/function.array-merge.php

http://www.php.net/manual/en/function.array-reduce.php

Im assuming your $errors array looks like this: $errors = array(array('message 1'), array('message 2'), array('message 3'));

Then you could use something like this:

$msg = ''; foreach($errors as $inner) {$msg .= current($inner) . '
'; } echo$msg;
// message 1
message 2
message 3

I dont know if its more efficient than the 2 foreach loops though.

On the other hand I personally would look into modifying the getMessages() mehtod so that it returns a single array and not a multidimensional one. With a single array you just need to implode it with a 'br' :)

• by using current() it not get all $error in$errors :( – hungneox Dec 14 '11 at 15:43

Given errors like this:

$errors = array(array('message 1a','message 1b'), array('message 2'), array('message 3'));  I you could make a function that can call itself to account for the nested arrays. function showErrors($errors) {
foreach ($errors as$error) {
$msg .= (is_array($error))? showErrors($error) :$error.'
';
}
return($msg); }$msg = showErrors(\$errors);

Not sure it's cleaner, but it may be more versatile. This will accommodate deeper nested arrays should the need arise. If possible, I like Pratt's suggestion of supplying a single array.


text:
SDL_BlitSurface() setting the dest Rect's coords to 0...

This topic is 4403 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

Recommended Posts

I've been having this problem for a while now. For some reason, when I blit a surface, if the X- or Y- coordinates are less than zero, the SDL_BlitSurface() function is setting them back to zero... this means that if, for example, the player fires a missile from the ship, it just stops dead at the top of the screen. I can't figure this out for the life of me, and I haven't seen any other games that are having this problem... any ideas?

Share on other sites
post your code and let us take a look

Share on other sites
just to make sure...

make a function to blit like this

void apply(int x,int y,SDL_Surface* source, SDL_Surface* destination)
(
SDL_Rect offset;

offset.x = x;
offset.y = y;

SDL_BlitSurface(source,NULL,destination,&ofset);
}

Share on other sites
SDL_Rect offset;offset.x = x;offset.y = y;SDL_BlitSurface(source,NULL,destination,&offset);

SDL_BlitSurface stores the *clipped* rectangle in offset...
is that what you mean?

or is the image actaully stopping at the top left? (it doesnt on my SDL programs)

Share on other sites
Well... I got it working, but I'm not sure WHY.

In the Sprite's Render() function, instead of blitting using the Sprite class's private Rect member for the dst, I dereferenced it and created a copy and used the copy for blitting... I don't really see why this would make a difference, though.

EDIT: Nevermind, it all made sense after I gave it a little thought.

Share on other sites

This topic is 4403 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

• Forum Statistics

• Total Topics
628740
• Total Posts
2984470

• 12
• 25
• 11
• 10
• 16


text:
Timezone: »

Poster
A Gaussian Process Model of Quasar Spectral Energy Distributions
Andrew Miller · Albert Wu · Jeffrey Regier · Jon McAuliffe · Dustin Lang · Mr. Prabhat · David Schlegel · Ryan Adams

Thu Dec 10 08:00 AM -- 12:00 PM (PST) @ 210 C #16 #None

We propose a method for combining two sources of astronomical data, spectroscopy and photometry, that carry information about sources of light (e.g., stars, galaxies, and quasars) at extremely different spectral resolutions. Our model treats the spectral energy distribution (SED) of the radiation from a source as a latent variable that jointly explains both photometric and spectroscopic observations. We place a flexible, nonparametric prior over the SED of a light source that admits a physically interpretable decomposition, and allows us to tractably perform inference. We use our model to predict the distribution of the redshift of a quasar from five-band (low spectral resolution) photometric data, the so called `photo-z'' problem. Our method shows that tools from machine learning and Bayesian statistics allow us to leverage multiple resolutions of information to make accurate predictions with well-characterized uncertainties.


text:
The SlugMath Wiki is under heavy development!

# Def/Union

(diff) ←Older revision | Current revision (diff) | Newer revision→ (diff)

Definition of Union: If $X$ is a set, then $\bigcup X$ is the set whose elements are those $u$ which are elements of elements of $X$. In other words, $$x \in \bigcup X \mbox{ iff } \exists u \in X, x \in u.$$

The set $\bigcup X$ is called the union (of the elements) of $X$.

When $X$ is an unordered pair, such as $X = \{ A, B \}$, one uses the notation $A \cup B$ to stand for $\bigcup \{A, B \}$.

## Logical Connections

This definition logically relies on the following definitions and statements: State/Axiom of unions, State/Axiom of extensionality

The following statements and definitions logically rely on the material of this page: Def/Ordinal number, Def/Successor, and State/Axiom of infinity

To visualize the logical connections between this definition and other items of mathematical knowledge, you can visit any of the following clusters, and click the "Visualize" tab: Clust/Basic set theory


text:
Math and Arithmetic
Statistics

# Is an arithmetic mean a weighted mean or a weighted mean an arithmetic mean?

012

###### 2012-12-14 16:49:38

The arithmetic mean is a weighted mean where each observation is given the same weight.

🙏
0
🤨
0
😮
0
😂
0

## Related Questions

There is. Arithmetic mean is simple average of numbers not weighted by anything. However in EV, the numbers are weighted by their probability

The arithmetic mean and the weighted mean are used in different situations. The arithmetic mean is used in frequencies as a general average. The weighted mean is used when different factors contribute to some kind of total for example with weighted index numbers. It is not a matter of accuracy it involves using the right mean in the right situation. Almost always (if not always) a question will specify which mean to use.

The weighted mean is simply the arithmetic mean; however, certain value that occur several times are taken into account. See an example http://financial-dictionary.thefreedictionary.com/weighted+average

The weighted arithmetic mean is used, if one wants to combine average values from samples of the same population with different sample sizes: : The weights wi represent the bounds of the partial sample. In other applications they represent a measure for the reliability of the influence upon the mean by respective values. rhinostar

The plain arithmetic mean is actually a special case of the weighted mean, except all the weights are equal to 1. The arithmetic mean is the sum of all the individual observations divided by the number of observations. With a weighted mean you multiply each observation by a weight, add those values together and then divide by the sum of the weights. E.g. Let's say you have 3 observations: 4, 7, 12 The arithmetic mean is (4+7+12) / 3 = 23/3 = 7.67 Now let's assume that you want to weight the first observation by a factor of 10, the second observation by a factor of 5 and the third observation by a factor of 2: The weighted mean is (4x10+7x5+12x3) / (10+5+2) = 111/17 = 6.53 You can see that if all the weights were 1 you would have the arithmetic mean shown above. As it is mentioned above arithmetic mean is a special case of weighted mean. In the calculation of arithmetic mean all the observations are given an equal chance of occurance ie the above mentioned problem can be written as 4*1/3+7*1/3+12*1/3=7.67 or inother words 7.67 is the number it takes if all are given equal chance whereas in weighted mean the chance of occurance are not equal .This can be written as 4*10/17+7*5/17+12*2/17=6.53 in the above eg. 4 has given more weightage than 7 and 12 has the least weightage so the probability of 4 occurring is more when compared to 7 and 12 there fore the average obtained is seen to decrease as we have given more importance to 4 than others. It shows that the average is affected by the weightage given to the numbers

An adjective form is arithmetic, or arithmetical. They mean of or based on arithmetic.

Arithmetic:The computing of numerals and numbers.

1.The Geometric mean is less then the arithmetic mean. GEOMETRIC MEAN < ARITHMETIC MEAN 2.

A weighted mean is when some values contribute more than others. In order to calculate weighted mean multiply each weight by its value, add those and then divide by the sum of the weights.

The arithmetic mean of a single number, such as 1784298281, is the number itself.

Arithmetic is another word for math or mathematics.

weighted mean is getting the weighted average of students. normally, it is always use in computing the general average of the students to determine the ranking of the whole class.

double weightedmean (double runningaverage, double rawdata, double timeconstant) { return runningaverage / (1 - 1/timeconstant) + rawdata / (1/timeconstant); }

You need to have all the values within the range to calculate the arithmetic mean .

arithmetic mean is the average (175+235) / 2 = 205

when is it appropriate to use arithmetic mean as opposed to median

The arithmetic mean of one number, such as 104410231017 is still simply that number.

Two numbers can have only one arithmetic mean. In this case, it is -2.5Two numbers can have only one arithmetic mean. In this case, it is -2.5Two numbers can have only one arithmetic mean. In this case, it is -2.5Two numbers can have only one arithmetic mean. In this case, it is -2.5

Any two numbers can have only one arithmetic mean. If the numbers are x and y, then their arithmetic mean is (x + y)/2.

The answer will depend on how many cases each person can handle. If the handlers all work at similar speeds then an arithmetic mean speed will do both otherwise you will need a weighted average - weighted according to the number of 8-hour shifts that they can put in.

The difference between arithmetic and geometric mean you can find in the following link: "Calculation of the geometric mean of two numbers".

There are a great number of advantages and disadvantages of Arithmetic mean. One disadvantages is that it is not accurate.

###### Math and ArithmeticStatisticsFord Explorer Sport TracThe Giver Book SeriesAdjectives and ArticlesRelationshipsGrades and Grade Point Averages (GPA)Mathematical FinanceComputer Programming

Copyright © 2020 Multiply Media, LLC. All Rights Reserved. The material on this site can not be reproduced, distributed, transmitted, cached or otherwise used, except with prior written permission of Multiply.


text:
# Can I “raise a bounty” for a contest?

I would like to ask a contest-style problem on puzzling SE and I came up ith an interesting idea. Could I start a contest in a post and offer all reputation that I recieve as upvotes on that question as a bounty prize for the winner?

If not, can you give other suggestions as to how I might conduct a contest? Is this even allowed?

• Could you clarify a little what you mean by "a contest-style problem"? Thanks. – Gareth McCaughan Mod Jun 15 '17 at 10:14

So far as I know, there's no mechanism that will automatically have that effect.

You can certainly make a promise that you will "donate" reputation from upvotes to a particular question as a bounty. However:

1. Bounties only come in multiples of 50 points. Upvotes on questions are only worth 5 points each. So in order to get enough upvotes to make a minimal bounty, your question would have to get at least +10. That's not terribly unlikely if the question is well-received, but it's by no means guarantee.

2. If you do manage to post a question that gets enough favourable attention to earn you enough reputation to equal a bounty payment, then very likely the best answer(s) will already be getting plenty of upvotes. And upvotes on answers are worth 10 points each, and good answers tend to attract more upvotes than good questions. So your bounty will probably not, in practice, be a very large incentive.

3. If you say "rep I gain from this question will be handed out in bounty" then, especially as you actually can't do that exactly unless the number of upvotes you get happens to be a multiple of 10, some users may suspect that this is really a ploy to get rep for yourself. (Or to gain upvotes, which look good even if you then sacrifice all the resulting rep as a bounty.) Even if they're 100% wrong, they may believe it, and the result may be hard feelings on one side or the other or both.

4. It's not at all clear why a good solution should be better rewarded if the question is higher-voted. What do those two things have to do with one another?

In view of all this, my feeling is that if you want to do something like this then you should probably decouple the bounty from the upvotes on your question. Just say "The best answer will receive a 50-point bounty" or whatever. You may end up losing Imaginary Internet Points overall in this case, but that doesn't seem like a terribly scary risk; they're only Imaginary Internet Points. And if your challenge is well received you may come out net positive, which actually seems only fair.

• I agree with everything you've said, but you've focused only in the logistics of awards and don't address the issue of effectively breaking the current "too broad" policies. – Alconja Jun 15 '17 at 2:58
• True. That would be another problem with the whole scheme. It feels like there are really two quite separate questions here: (1) "can I ask a contest-style question looking for the best answer rather than the unique right answer?" and (2) "can I reward it with a bounty in such-and-such a way?". My answer is all about #2. – Gareth McCaughan Mod Jun 15 '17 at 10:11
• (#1) sounds like just an open-ended question to me – dcfyj Jun 15 '17 at 15:57
• @dcfyj - only if there's an objective measure for determining the winner. If it's just a popularity contest, or the one that op likes the most then it moves into "too broad" territory. – Alconja Jun 15 '17 at 21:53

What follows is my personal opinion and not policy... (i.e. before doing anything see how the votes on this or any other answer plays out, to gauge general community consensus)

I have seen questions asked on the main site in the past that effectively constitute "contest" questions and they've been closed as too broad. This is strictly true under the current policies and I don't think you'd have much luck taking that approach.

That being said, we also have precedent for "open ended" bounties here on meta, and we similarly have precedent for topic challenges and other community "events", so I think there's still wiggle room to work with.

So, if this were to work, I think the way to go about it would be to create your "challenge" post here in meta, stating your contest restrictions and proposed deadlines/prizes, so that participants can post their entries as unique puzzle posts (each individually following normal site rules). People could then post on the meta question ...i.e. basically make it like a custom version of the normal fortnightly topic challenge.

Two challenges/problems I foresee though:

1. You may get some community resistance because it arguably competes with the existing FTC process, which is more democratic
2. You'd receive no bounty from your question to pass on to the winner, so you'd have to find alternative ways to "fund" it*

My personal opinion is that we should absolutely support this sort of community activity, so I'm all for it (under the FTC-style structure described above).

* If the general idea gets community consensus, and I personally find the contest topic interesting, I'd be happy to contribute to the prize pool.

• This answer assumes, unless I'm misunderstanding, that by "contest-style problem" Nilknarf means a question inviting the making of other questions. I interpreted it more broadly: to mean a question with lots of possible answers where the goal is to get as good an answer as one can rather than the provably best answer or the unique correct answer. I wonder which was intended. – Gareth McCaughan Mod Jun 15 '17 at 10:14
• @GarethMcCaughan - you're right. I interpreted "contest" to mean "make a puzzle" (similar to FTC), but now that you point it out, that's very much not clear from the question... If the intention was a contest looking for the best answer, then I think there's clearer policy at least (either it's ok, as per existing open ended puzzles assuming there's a measurable/objective "best", or it's not ok/too broad if it's just a popularity contest). – Alconja Jun 15 '17 at 10:50
• I interpreted different than both of you. I took this to be, can I make a question or puzzle that should be difficult, and see how can solve it fastest, most efficiently, most creatively etc etc. Rewards going to those answers. So while it may be broad, it'd still have an answer, but the means of getting it may vary. - granted if that's the case, it sounds like that'll be more of a math problem or lateral thinking which may not fair well. – n_plum Jun 15 '17 at 12:44

To me, this sounds like a great idea!

As to how it could be done, you could list the bounty conditions at the bottom of the puzzle, and when done you could award a bounty corresponding to $\left\lfloor\dfrac{question\_upvotes}{10}\right\rfloor\cdot50$ reputation (what you receive, rounded down to highest multiple of 25 below that).

I don't see any problems with this, though I haven't been on this site for very long, so I'll defer to some more experienced site members for this.

• Except that bounties can only be awarded in discrete amounts, as mentioned by @Gareth. You would need at least 10 upvotes to even be able to provide a bounty from the reputation, and you would have to either over-bounty or under-bounty unless your rep from upvotes happened to exactly match an existing bounty amount. – GentlePurpleRain Mod Jun 15 '17 at 14:27
• @GentlePurpleRain That's what the formula does (or at least I think it does). – boboquack Jun 15 '17 at 21:54


text:
# Why is it legitimate to perform multiplication with differentials dx?

Why is it legitimate to perform multiplication with differentials $dx$?

For instance, from the statement $dy = 5dx$ one derives $\frac{dy}{dx} = 5$.

I learned $\frac{dy}{dx}$ as a notation to mean the limit of the rate of change.

In this MIT OpenCourseWare video, the professor states that $dx$ is not a number but doesn't define what it is precisely.

Is there a book/online doc that talks about why it is legitimate to manuplate $dx$ as if it were a value?

• $df(x)$ is defined as $df(x) := f'(x)dx$. So it's not that you're dividing by $dx$ on both sides, it's just that you're recognizing $5$ as the derivative of $y$ from your equation. As for a book on differential forms, how good is your multivariable calculus? If you're pretty confident on it, check out the answer to this question. If not, you're just going to have to wait for now. – user137731 Nov 18 '15 at 1:19
• I didn't know there is a definition for df(x) .. Where can I learn that? – eugene Nov 18 '15 at 1:20
• Any book on differential forms. For a really brief introduction you could take a look at this pdf. It defines $df$ on page $3$ with partial derivatives, but of course if $f$ is a function of only $1$ variable, then you'd just use the regular derivative. – user137731 Nov 18 '15 at 1:20
• The direction you're questioning makes me curious. $\;\;\;$ How did you get $\: dy = 5dx \:$ in the first place? $\;\;\;\;\;\;\;\;$ – user57159 Nov 18 '15 at 1:45
• I just gave a simple example I could make up, it's presented in the class (online lecture) – eugene Nov 18 '15 at 2:02

A lot of the manipulations people do with differentials can be understood by thinking of $dx$ as a differential form. Unfortunately, it's hard to find a good introduction to differential forms that doesn't assume the reader is already very comfortable with calculus. You might try David Bachman's A Geometric Approach to Differential Forms.


text:
# Re: [NTG-context] Mutiple citations doesn't work with compress=no + interaction

On 09/06/10 11:24, Taco Hoekwater wrote:

Michael Murphy wrote:

On 08/06/10 20:47, taco wrote:

It also only happens in mkiv, something is broken there. As is
usual in the mkiv version of the bib module, I can't figure
it out :(

However, here is a workaround:

...

>

... and indeed, this works for the minimal example, but in my actual
document, I get an error:

! Undefined control sequence.
\dododescriptioncomponent ...entdescriptioncoding
\s!tex \fi \ifx

and I have no idea why. I guess I'll play around some more.

Wild guess: can you try with this definition in the setup part

\unexpanded\def\dodescriptioncomponent
{\doifelsedescriptioncomponent
\nododescriptioncomponent\dododescriptioncomponent}

Best wishes,
Taco

Thanks for the code, but that turns out not to help. The problem seems to be when I want to have references in footnotes (see attached minimal example).

--
Michael Murphy

\setuppublicationlist[samplesize={CKRGO08},totalnumber=3]

\startpublication[k=Balachandran2008,t=article,
a={{Balachandran},{Gong}},y=2008,o={10.1103/PhysRevA.77.012303},
n=1,s=BG08]
\artauthor[]{Vinitha}[V.]{}{Balachandran}
\artauthor[]{Jiangbin}[J.]{}{Gong}
\pubyear{2008}
\arttitle{Adiabatic quantum transport in a spin chain with a moving potential}
\journal{Phys. Rev. A}
\volume{77}
\issue{1}
\pages{012303}
\doi{10.1103/PhysRevA.77.012303}
\stoppublication

\startpublication[k=Borzi2002,t=article,
a={{Borz\i},{}},y=2002,
n=2,s=BSH02]
\artauthor[]{Alfio}[A.]{}{Borz\i}
\artauthor[]{Ulrich}[U.]{}{Hohenester}
\pubyear{2002}
\arttitle{Optimal quantum control in nanostructures: Theory and application to
a generic three-level system}
\journal{Phys. Rev. A}
\volume{66}
\stoppublication

\startpublication[k=Bose2007,t=article,
a={{Bose}},y=2007,o={http://dx.doi.org/10.1080/00107510701342313},
n=3,s=Bos07]
\artauthor[]{Sougato}[S.]{}{Bose}
\pubyear{2007}
\arttitle{Quantum communication through spin chain dynamics: an introductory
overview}
\journal{Contemporary Physics}
\volume{48}
\issue{1}
\pages{13}
\doi{http://dx.doi.org/10.1080/00107510701342313}
\stoppublication

\setupinteraction[state=start]

\usemodule[bib]
\setuppublications[refcommand=authoryears]

\let\NORMALcite\cite
\newif\ifSEEN
\def\cite#1[#2]{\SEENfalse
\def\processitem##1{\ifSEEN, \else\SEENtrue \fi \NORMALcite[##1]}%
(\processcommalist[#2]\processitem )}

\unexpanded\def\dodescriptioncomponent
{\doifelsedescriptioncomponent
\nododescriptioncomponent\dododescriptioncomponent}

\setupcite[authoryears][compress=no,left=,right=]

\starttext

I can cite single authors, like this \cite[Balachandran2008], and now I
can also do more than one\footnote{but unfortunately I get errors when I
have citations
\cite[Balachandran2008]
in footnotes}%
citation \cite[Balachandran2008,Borzi2002,Bose2007].
\blank
\placepublications

\stoptext

___________________________________________________________________________________


text:
# Data Types, Turtle Drawing, and Functions

Welcome to the first day of class!

Chapters 2, 4, and 6.

## Key ideas

### From chapter 2:

• Simple python types: int(eger), float, str(ing)
• Determing type: type
• Declaring and using variables
• Assignment token: =
• Arithmetic operators: +, -, *, /, //, %, **
• User input: input

### From chapter 4:

• Turtle Module Methods
• Creation: turtle
• Movement: forward, backward, goto
• x, y orientation: right, left
• Pen control: up, down, pensize
• Drawing Color: color, fillcolor, begin_fill, end_fill
• Status: heading, position
• Turtle type: shape, e.g. arrow, classic, turtle or circle
• Turtle Imprints: stamp, dot
• Looping Construct: for
• onclick(), onrelease(), ondrag() from turtle online documentation

### From chapter 6:

• Be able to write a function.
• Be able to call a function.
• Understand function parameters.
• Understand the difference between a fruitful function and a non-fruitful function.
• Understand the difference between a local variable and a global variable.

## Active learning

### Activity 1

Evaluate the following numerical expressions:

5 ** 2
9 * 5
15 / 12
12 / 15
15 // 12
12 // 15
5 % 2
9 % 5
15 % 12
12 % 15
6 % 6
0 % 7

### Activity 2

Download madlib.py and modify it to create your own story. Your modified Mad Lib should use (1) at least one input that is treated as a string, (2) at least one input that is treated as an integer and (3) at least one input that is treated as a floating point number.

### Activity 3

Look at racing-turtles.py and make sure that you understand it fully. Then,

1. Modify the program so that a third racing turtle starts at coordinate (-200, -100).
2. Write down three other improvements to the program.
3. Find someone to discuss your proposed improvements with.
4. Implement at least one of your proposed improvements.

### Activity 4

Look at etch-a-sketch.py and make sure that you understand it fully.

1. Write down three improvements you could make to the program.
2. Find someone to discuss your proposed improvements with.
3. Implement at least one of your proposed improvements.

### Activity 5

Which of the following best reflects the order in which these lines of code are processed in Python?

1  def pow(b, p):
2      y = b ** p
3      return y
4
5  def square(x):
6      a = pow(x, 2)
7      return a
8
9  n = 5
10 result = square(n)
11 print(result)

What does the program print?

### Activity 6

Improve house.py using functions.


text:
Metamath Proof Explorer < Previous   Next > Nearby theorems Mirrors  >  Home  >  MPE Home  >  Th. List  >  df-gch Unicode version

Definition df-gch 9020
 Description: Define the collection of "GCH-sets", or sets for which the generalized continuum hypothesis holds. In this language the generalized continuum hypothesis can be expressed as . A set satisfies the generalized continuum hypothesis if it is finite or there is no set strictly between and its powerset in cardinality. The continuum hypothesis is equivalent to . (Contributed by Mario Carneiro, 15-May-2015.)
Assertion
Ref Expression
df-gch
Distinct variable group:   ,

Detailed syntax breakdown of Definition df-gch
StepHypRef Expression
1 cgch 9019 . 2
2 cfn 7536 . . 3
3 vx . . . . . . . . 9
43cv 1394 . . . . . . . 8
5 vy . . . . . . . . 9
65cv 1394 . . . . . . . 8
7 csdm 7535 . . . . . . . 8
84, 6, 7wbr 4452 . . . . . . 7
94cpw 4012 . . . . . . . 8
106, 9, 7wbr 4452 . . . . . . 7
118, 10wa 369 . . . . . 6
1211wn 3 . . . . 5
1312, 5wal 1393 . . . 4
1413, 3cab 2442 . . 3
152, 14cun 3473 . 2
161, 15wceq 1395 1
 Colors of variables: wff setvar class This definition is referenced by:  elgch  9021  fingch  9022
 Copyright terms: Public domain W3C validator


text:
# Definition:Unit Length

A unit length is a straight line segment of arbitrary length can defined as having a length of $1$ (one).
During the course of the exposition arising from the definition a unit length $L$, all subsequent lengths can then be expressed as multiples of $L$.


text:
# Two players until one player wins three games in a row. Each player will win with probability $\frac{1}2$. How many games will they play?

QUESTION: Suppose two equally strong tennis players play against each other until one player wins three games in a row. The results of each game are independent, and each player will win with probability $$\frac{1}2$$. What is the expected value of the number of games they will play?

MY APPROACH: I have tried to set up some kind of recurrence relation here but could not succeed.. Observe that there can be at most a winning streak of $$2$$. A winning streak of $$3$$ means that the game ends.. If we assume that the number of $$1$$ game winning streak is $$x$$ and the number of $$2$$ game winning streak is $$y$$ then $$x+y+1$$ obviously yields the desired answer..

Note: A $$1$$ game winning streak simply means that they win alternately.. Since each one of them has a $$50\%$$ chance of winning therefore we can do this..

Now, somehow, we have to find the value of $$x$$ and $$y$$.. But here I am stuck.. With so less information, neither can I set up a recurrence relation, nor do I see any way to compute two variables..

Any help will be much appreciated.. :)

• @lulu Okay.... But I have doubt.. $E(A,A,2)$ means that $A$ has won the last two games and it is $A's$ turn now.. So the probability of winning the first game is half and the second game is also half.. So, since $A$ has to compulsorily win them, isn't it $\frac{1}2 . \frac{1}2 = \frac{1}4$.. From where do you get $(1+E(B,B,1))$ ? Aug 7 '20 at 7:07
• My comment was needlessly complex, as we don't actually care who holds the current winning streak. (Also in the first version of the comment I was considering different rules then the ones you wanted, so I deleted the comment). I posted something simpler below.
– lulu
Aug 7 '20 at 7:10
• @lulu Yes.. I am trying to get what your answer wants to say.. Aug 7 '20 at 7:13
• here is a duplicate question (phrased differently).
– lulu
Aug 7 '20 at 7:17

Recurrence works fine.

All we care about is the length of the current win streak, we don't even care who has been winning. Accordingly, let $$E_i$$ denote the expected number of games it will take if one player currently has a winning streak of length $$i$$. The answer we seek is $$E_0$$.

We get: $$E_2=\frac 12\times 1+\frac 12\times (1+E_1)=1+\frac 12\times E_1$$

Similarly $$E_1=1+\frac 12\times (E_1+E_2)$$ and $$E_0=1+ E_1$$

This is easily solved and yields $$\boxed {E_0=7}$$

• I have just one doubt.. discussed in the comment above... Aug 7 '20 at 7:10
• My earlier comment pertained to a different rule set than you wanted (so I deleted that comment). What doubt do you have for the argument I presented here? If the current win streak is $1$, say, then with equal probability either the current winner wins again, moving us to $E_2$ or the current winner loses, keeping us in $E_1$ and in either case we have played one game.
– lulu
Aug 7 '20 at 7:13
• Oh yes!! Thank you so much.. Aug 7 '20 at 7:16
• The addition of $1$ in every recurrence denotes that they are playing one game right?.... But what does that $\frac{1}2 \times 1$ in $E_2$ mean? Aug 7 '20 at 7:24
• For the first equation I wrote I considered two paths, according to who won. If the current streak holder wins it takes $1$ game to finish. If the current streak holder loses it takes $1+E_1$ games to finish, and both paths have probability $\frac 12$ of occurring.
– lulu
Aug 7 '20 at 7:25

Suppose the winner of the last game is on a $$1$$-game streak. How many more games until someone is on a $$2$$-game streak? This is just a geometric random variable with parameter $$1/2$$, so has expectation $$2$$.

Now, once someone is on a $$2$$-game streak, either they get a $$3$$-game streak next game, or you go back to someone being on a $$1$$-game streak. So from a $$1$$-game streak, after an expected $$3$$ games either someone completes a $$3$$-game streak or you are back where you started. The number of times this happens before you get a $$3$$-game streak is also exponential with parameter $$1/2$$, so has expectation $$2$$. Crucially, the number of stages of this form you have to go through is independent of the length of each stage. So the total time for all stages has expectation $$2\times 3=6$$. This is the expected time from the position where someone is on a streak of $$1$$, i.e. the expected number of games needed after the first game, so the total expectation is $$7$$.

• What do you mean by 'geometric random variable with parameter' ? Aug 7 '20 at 7:25
• @StrangerForever Have a look at geometric distribution Aug 7 '20 at 7:40


text:
### Data associated with \"Phase domain boundary motion and memristance in gradient-doped FeRh nanopillars induced by spin injection\"

Rowan Temple, Mark C. Rosamond, Jamie Massey, Trevor Almeida, Edmund Linfield, Damien McGrouther, Stephen McVitie, Thomas Moore & Christopher Marrows
The B2-ordered alloy FeRh shows a metamagnetic phase transition, transforming from antiferromagnetic (AF) to ferromagnetic (FM) order at a temperature $T_\mathrm{t} \sim 380$~K in bulk. As well as temperature, the phase transition can be triggered by many means such as strain, chemical doping, or magnetic or electric fields. Its first-order nature means that phase coexistence is possible. Here we show that a phase boundary in a 300~nm diameter nanopillar, controlled by a doping gradient...
This data repository is not currently reporting usage information. For information on how your repository can submit usage information, please see our documentation.


text:
# Line Balancing Part 4 – OEE Usage and Flexibility

In the previous post we looked at the potential problems when using an OEE for line balancing. Now, in the fourth post on line balancing, we actually use the OEE to create target cycle times (or, alternatively, a target line takt) for our system before we start balancing the system in the next post.

## What to Do with OEE

In any case, now you have the OEE and can calculate the target cycle time based on the customer takt (or, if you prefer it the other way round, calculate the target line or process takt based on the cycle times of the individual tasks). Here again, you have multiple options on how to proceed.

### Target Line Cycle Time

The easiest way to do this is to assume that the losses, and hence the OEE, is pretty much the same across all tasks and parts. You also assume that the entire system is working at the same time (i.e., either all processes work or all are off-shift).

The target cycle time for all processes is then simply the takt time multiplied by the OEE. If, as in the example above, your takt time is 60 seconds, and your OEE is 80%, then all processes have a target cycle time of 48 seconds.

This is by far the easiest approach. If you can make the assumption above, then your life will be easier.

### Target Process Cycle Time

Sometimes, you have processes where you know that the OEE is different. For example, in your production system you may have one machine that gives you nothing but trouble. If it is mostly trouble that is bigger than the buffers to the adjacent processes, then this is reflected in the OEE of the other processes anyway. However, if there are lots of little problems, then you may choose to use a different OEE for selected processes.

Yet, you mostly can avoid this. If the OEE differs by less than 10%, I would not really bother too much. In my experience, OEEs are not that precise anyway. Additionally, due to interdependence between processes in a flow line, it is rare that one process is significantly better or worse than the rest of the system. Hence, unless you absolutely feel the need to treat one process separately, don’t!

### Target Process and Product Specific Cycle Time

Distinguishing the OEE by different processes can even be pushed one step further by also distinguishing by different product types. For example, product A may give you much more trouble than product B. In this case, you could have separate OEEs for different products. But, be warned, you are opening a can of worms that is not easily swallowed (and let me know if I am mixing incompatible metaphors 😉 ).

First of all, do you know your OEE by product type? It may be difficult to separate the OEE for different products. Secondly, you would need to do the calculation “the other way around.” Normally, I take the customer takt and calculate a target cycle time using the OEE. Then I group my tasks into suitable processes that are roughly as fast as the target. However, the task times are by themselves an average. Either I take the task times for the high runners and assume all others are the same, or I create weighted averages (see above).

But by then it is too late to distinguish by product type. Hence, if you really want product-specific OEEs, you would have to take the task times for the individual products and divide them by the appropriate OEE into the task takt time for the individual products. Only now you can combine the task takt times for either the high runner or the weighted average of all products, and then group them into processes where the process takt time matches the customer takt time. Hence, again, unless you absolutely feel the need to treat products separately, don’t!

## How Flexible Are You?

An important factor is the flexibility you have in changing your system. By “flexibility,” I mean mainly two things:

Sequence Flexibility: How much can you change the sequence of the processes? Some processes are a prerequisite for another process. Others, however, can be moved before or after another process. The more you can move the processes around, the easier it will be later to design a well-balanced system. There are probably software systems where you can enter the possible sequences; however, this is a lot of work. I would rather play around with the sequence later and see what works instead of spend lots of time adding dependencies into a software tool and then hope that the tool will give me a good result. Hence, as for data collection, you need to be aware of the possibilities of changing the sequence, but in my view it is too much work to actually define it beforehand.

Grouping Flexibility: If it consists mostly of manual work, you have lots of flexibility in grouping the work. If you buy new machines or have universal tooling machines, then you may also have flexibility in deciding which machine does which sub-processes. If you already own dedicated machines for the processes, then you probably have the least flexibility. Hence, some processes can be grouped together with other processes, whereas others have to be an individual cycle. Overall, manual processes are much easier to work with here. Similar to the sequence flexibility, I do not summarize my options beforehand, as this would be too much work. I’d rather play around with different sequences later and then check if they work.

## Quick Summary so Far

By now we should have a good overview of the system and all the data we need for the balancing of the line:

• List of tasks and the times needed for the tasks. May be based on high-runner example, weighted average, or multiple sets for multiple products. Usually, it is a task cycle time, but may also be a task takt time including the losses. Should include all tasks that are necessary to make any of the products that have to pass through the system.
• Target cycle time needed to achieve the customer takt with respect to losses (OEE), if your task times do not include losses. If your task times include losses, this should be simply the customer takt. Usually, it is the target cycle time or customer takt across all products, but in rare cases it may be distinguished by product type.
• Some understanding on flexibility in the sequence and the grouping, not necessarily in an exhaustive data set but rather in your head.

At this point you can also make a quick estimate on the number of stations or workers you probably need. You take the sum of all task cycle times and divide it by the target cycle time. For example, if you have work for 460 seconds, and have a target cycle time of 48 seconds, then you would need ${\frac{460 s}{48 s}}$ = 9.58 stations or workers. This means that after balancing you probably need around 10 stations or workers in your system.

Now we can actually start balancing the line 🙂 . In the next post I will explain how to do it on paper (my preferred method), before explaining how to do it on a computer and showing you some tricks in the post afterward. Until then, stay tuned and organize your industry!

## Line Balancing Series Overview

1. Data Overview: List of products, list of tasks, and customer takt
2. Duration of Tasks: How to get the duration of tasks, especially if they differ among products
3. OEE Caveats: Potential problems when using the OEE to transform takt times to cycle times
4. OEE Usage and Flexibility: Once you have the OEE, how do you use it? Also a bit on flexibility.
5. Balancing using Paper: Finally, actual line balancing using paper
6. Tips and Tricks for Balancing: Some Pro-Tips, and also a bit about line balancing using computers

## 4 thoughts on “Line Balancing Part 4 – OEE Usage and Flexibility”

1. I love the practical shortcuts in this, Christoph.


text:
## Cryptology ePrint Archive: Report 2019/1230

Linear-Size Constant-Query IOPs for Delegating Computation

Eli Ben-Sasson and Alessandro Chiesa and Lior Goldberg and Tom Gur and Michael Riabzev and Nicholas Spooner

Abstract: We study the problem of delegating computations via interactive proofs that can be probabilistically checked. Known as *interactive oracle proofs* (IOPs), these proofs extend probabilistically checkable proofs (PCPs) to multi-round protocols, and have received much attention due to their application to constructing cryptographic proofs (such as succinct non-interactive arguments).

We prove that a rich class of NEXP-complete problems, which includes machine computations over large fields and succinctly-described arithmetic circuits, has constant-query IOPs with O(T)-size proofs and polylog(T)-time verification for T-size computations. This is the first construction that simultaneously achieves linear-size proofs and fast verification, regardless of query complexity.

An important metric when using IOPs to delegate computations is the cost of producing the proof. The highly-optimized proof length in our construction enables a very efficient prover, with arithmetic complexity O(T log T). Hence this construction is also the first to simultaneously achieve prover complexity O(T log T) and verifier complexity polylog(T).

Category / Keywords: foundations / interactive oracle proofs; probabilistically checkable proofs; delegation of computation

Original Publication (with major differences): IACR-TCC-2019

Date: received 19 Oct 2019, last revised 23 Oct 2019

Contact author: alexch at berkeley edu

Available format(s): PDF | BibTeX Citation

Short URL: ia.cr/2019/1230

[ Cryptology ePrint archive ]


text:
# Mesh refinement¶

Mesh refinement with the Bank et all method (see [bank1983]) is available in dimension 1, 2 or 3 for simplex meshes (segments, triangles and tetrahedrons). For a given object mymesh of type getfem::mesh, the method:

mymesh.Bank_refine(bv);

refines the elements whose indices are stored in bv (a dal::bit_vector object). The conformity of the mesh is kept thanks to additional refinement (the so called green triangles). Information about green triangles (in Figure Example of Bank refinement in 2D) is stored on the mesh object to gather them for further refinements (see [bank1983]).

Example of Bank refinement in 2D

Mesh refinement is most of the time coupled with an a posteriori error estimate. A very basic error estimate is available in the file getfem/getfem_error_estimate.h:

error_estimate(mim, mf, U, err, rg);

where mim is the integration method (a getfem::mesh_im object), mf is the finite element method on which the unknown has been computed (a getfem::mesh_fem object), U is the vector of degrees of freedom of the unknown, err is a sufficiently large vector in which the error estimate is computed for each element of the mesh, and rg is a mesh region bulild from elements on which the error estimate should be computed (a getfem::mesh_region object).

This basic error estimate is only valid for order two problems and just compute the sum of the jump in normal derivative across the elements on each edge (for two-dimensional problems) or each face (for three-dimensional problems). This means that for each face of the mesh the following quantity is computed:

where is the jump of the normal derivative. Then, the error estimate for a given element is the sum of the computed quantities on each internal face multiplied by the element diameter. This basic error estimate can be taken as a model for more elaborated ones. It uses the high-level generic assembly and the neighbour_elt interpolate transformation (see Evaluating discontinuities across inter-element edges/faces).

#### Previous topic

Selecting integration methods

#### Next topic

Compute arbitrary terms - high-level generic assembly procedures - Weak-form language