text:
# ideal operations

Let $R$ be a commutative Noetherian ring, $\mathfrak{a}$ an ideal and $x, y$ elements. Is it true that $$\mathfrak{a}(\mathfrak{a}:x) \cap \mathfrak{a}(\mathfrak{a}:y) = \mathfrak{a}(\mathfrak{a}:(x,y))?$$

-
Acutally, I voted to close this, but I then realized that it was not as trivial as I thought. Sorry! I'd retract my vote to close if I could... –  Andy Putman Jan 31 '13 at 16:01
I need this equation for my problem. However, I think it should have a counterexample. –  Pham Hung Quy Jan 31 '13 at 16:26
It is true that $(\mathfrak{a}:x)\cap(\mathfrak{a}:y)=(\mathfrak{a}:(x,y))$ (see Atiyah-Macdonald p. 8, Ex. 1.12(v)). So the question is, what happens after both sides are multiplied by $\mathfrak{a}$? –  Mahdi Majidi-Zolbanin Jan 31 '13 at 17:03
Let $R=\mathbb{C}[a,b,x,y]/\langle abx-aby\rangle$. And let $\mathfrak{a}=\langle ax,by\rangle$. Now $aby\in \mathfrak{a}(\mathfrak{a}:x)\cap \mathfrak{a}(\mathfrak{a}:y)$ but $aby\notin \mathfrak{a}(\mathfrak{a}:\langle x,y\rangle)$. This should be your counterexample. –  Patrik Feb 1 '13 at 14:37
That's a nice example. Why don't you post that as an answer? –  Mahdi Majidi-Zolbanin Feb 1 '13 at 16:30

Let $R=\mathbb{K}[a,b,x,y]/\langle abx-aby\rangle$ and $\mathfrak{a}=\langle ax,by\rangle$.
Now $abx\in\mathfrak{a}(\mathfrak{a}:x)\cap\mathfrak{a}(\mathfrak{a}:y)$ but $abx\notin\mathfrak{a}(\mathfrak{a}:\langle x,y\rangle)$.


text:
# Modified Bellman Ford to find minmum cost cycle in O(E²V) time?

I'm thinking about how you can modify Bellman Ford a bit to calculate the minimum weight cycle in an undirected graph with positive weights. Note that the constraint is that the algorithm must run in $O(VE^2)$ times, and Bellman Ford runs $O(VE)$ time so we are looking at a modification that runs $O(E)$

My approach is first make a directed graph by doubling the edges in both directions, then run Bellman Ford to come up with the shortest path, then compute the strongly connected components in this graph. After you have a tree of strongly connected components, calculate the weights around the perimeter of the SCC and then compare the weights. But I'm not sure how you could calculate SCC using Bellman Ford and this algorithm is going to take too long.

Does anyone see an obvious solution?

format: plain


text:
## network file folder mapping from windows to Novell

I'm not sure this is the best discussion group for this question, but I
didn't see one that fit well.

I'm trying to map folders on a Novell network from a non-Novell client
computer attached to the same network router. I'm trying to create a
batch file for them to map shared folders on the server. Using this
syntax I consistently get "System error 53: network path cannot be found":

Net use N: \\servername\volume\share /user:username password

They syntax for windows to windows networks should be correct and the
server path is consistent with what is set up on the Novell network. I'm
just wondering if either the syntax for windows to Novell networks is not
correct or something is not allowing the mapping to proceed. Thoughts?

Thanks, Dave


text:
• Shailesh A Shirali

Articles written in Resonance – Journal of Science Education

• Creating Nice' Problems in Elementary Mathematics -- I

We consider here the meta-problem' of creating nice' problems in elementary mathematics, nice' being defined as a problem in which the input data, as well as the answers, are rational numbers. The classical example of this is that of generating Pythagorean triples. Many examples of this kind arise when we study Euclidean geometry and the theory of equations. We consider a few problems of this genre.

• Creating Nice' Problems in Elementary Mathematics -- II

We consider here the meta-problem' of creating nice' problems in elementary mathematics, nice' being defined as a problem in which the input data, as well as the answers, are rational numbers. The classical example of this is that of generating Pythagorean triples. Many examples of this kind arise when we study Euclidean geometry and the theory of equations. We consider a few problems of this genre.

• Creating ‘Nice’ Problems in Elementary Mathematics – III

We consider here the ‘meta-problem’ of creating ‘nice’ problemsin elementary mathematics, ‘nice’ being defined as aproblem in which the input data, as well as the answers, arerational numbers. The classical example of this is that ofgenerating Pythagorean triples. Many examples of this kindarise when we study Euclidean geometry and the theory ofequations. We consider a few problems of this genre.

• # Resonance – Journal of Science Education | News

• Posted on 13 July 2021
• # Workshop in Algebra, 7–9 September 2021

Posted on 9 August 2021


text:
What will happen if there are many objects with the same density but different size, all fall from the same height.
The terminal velocity $v=\sqrt{mg/b}=\sqrt{\rho Vg/b}$, so the terminal velocity is proportiobal to $\sqrt{V}$ where $V$ is the volume of the object.

The following simulation try to illustrate the size effect on terminal velocity.
The ratio of the mass for the object is 1:2:3:4:5:6:7:8:9
Because it is a 2D simulation, the radius is proportional to $\sqrt{m}$.

You can try it with different gravity g , or drag constant (Drag force = bv[sup]2[/sup])

/htdocs/ntnujava/ejsuser/2/users/ntnu/fkh/basic/terminalvelocitysets_pkg/terminalvelocitysets.propertiesFull screen applet or Problem viewing java?Add http://www.phy.ntnu.edu.tw/ to exception site list


text:
### On Kannan-Geraghty maps as an extension of Kannan maps

#### International Journal of Maps in Mathematics - IJMM

View Publication Info

 Field Value Title On Kannan-Geraghty maps as an extension of Kannan maps Creator Fogh, Fatemeh Behnamian, Sara Pashaie, Firooz Description Extending the concept of weakly Kannan maps on metric spaces, we study the maps as $f:X\rightarrow X$ on a metric space $(X, d)$ satisfying condition $d(f(x), f(y)) \leq (1/2)\beta(d(x, y))[d(x ,f(x)) + d(y, f(y))]$ for every $x, y\in X$ and a function $\beta: [0, \infty)\rightarrow [0,1)$ where for every sequence $t=\{t_n\}$ of non-negative real numbers satisfying $\beta(t_n)\rightarrow 1,$ while $t_n\rightarrow 0$. Such a map is named the Kannan-Geraghty map because of its relation to weakly Kannan map and Geraghty contraction. Firstly, we show that our new condition is different from weakly Kannan condition. Having proven the fixed point theorem, we present two useful results on Kannan-Geraghty maps. Also, we illustrate some examples of Kannan-Graghty map having interesting properties. Publisher Bayram Şahin Date 2019-03-22 Type info:eu-repo/semantics/article info:eu-repo/semantics/publishedVersion Format application/pdf Identifier http://www.journalmim.com/index.php/ijmm/article/view/28 Source International Journal of Maps in Mathematics - IJMM; Vol 2 No 1 (2019): International Journal of Maps in Mathematics; 1-13 2636-7467 Language eng Relation http://www.journalmim.com/index.php/ijmm/article/view/28/25 Rights Copyright (c) 2019 International Journal of Maps in Mathematics - IJMM


text:
Assembly is the closest resembling programming language to pure machine code instructions. The available instructions depend on the architecture and even supported extensions. In this tutorial the available instructions will be limited to the most basic set of RISC-V instructions. This set of instructions is denoted as RV32I meaning that it entails RISC-V 32 bit basic integer instructions. Not only will this limited set simplify the explanation and subsequently aid the understanding. More important, the Ripes simulator only supports RV32I and RV32M extensions. Here the RV32M identifies that multiplication instructions are also available to be performed on integers. Before continuing with the installation of Ripes lets briefly consider the available extensions for RISC-V today. Take into account that these extensions are being actively worked on, new extensions get drafted and existing extensions get updated.

## Extension Overview [1]

• A – Atomic instructions
• B – Bit manipulation instructions
• C – Compressed instructions
• D – Double-precision floating-point instructions.
• E – Embedded applications, resource constrained subset
• F – Single-precision floating-point instructions
• G – General (I + M + A + F + D)

• I – Integer instructions
• J – Dynamically translated languages
• L – Decimal floating-point instructions
• M – Integer multiplication and division instructions
• N – User-level interrupt instructions
• T – Transactional memory instructions
• V – Vector operations instructions

These extensions are the instruction extensions as defined for the user-level ISA specification 2.2 [2]. In addition to this specification there are also the unprivileged ISA specification [3], privileged ISA Specification [4] and a debug specification [5]. All these extensions and specifications might seem excessive but they allow for great flexibility. This flexibility will allow to create low power tiny microprocessors with only integer arithmetic. As well as full desktop processors with vector extensions. Furthermore, even special designed processors such as secure processors with separate program and data memory are possible.

## Understanding Basic Assembly

In a nutshell, assembly instructions perform read, write or arithmeti operations on either registers or memory addresses. These registers are locations inside the processors of a specific length to which can be read from or written to. Typically the available registers depends on the extensions implemented by the processor. One can think of registers as short term memory. Places to store temporary information so it can be written down (to memory) later. For the RV32I extensions there will be 32 individual 32bit long registers labeled x0 to x31. For Convenience many of these registers have specific names which indicates their purpose. In reality this is just for semantics and one is free to use any register for their desired purpose. Compilers, however, operate under the assumption that they can use certain registers consistently. To correctly identify return types for example.

### First Instruction

The first instruction to consider is called addi this is short for add immediate. Just like functions these instructions take arguments were in the case of addi three arguments are expected. First is the register to store the immediate into, second is the first integer and third is the second integer. The addition of the first and second integer will be stored in the specified register. Consider the example shown below were the addition of 0 + 5 is stored in the a0 (x11) register.

addi a0, zero, 5

Since an integer is a 32bit value it can only represent a limited range of discrete numbers. When adding to sufficiently large integers the addition can no longer represent the entire discrete number and it overflows. In other ISAs such as X86 such an overflow will set a flag in specific register. Such flags allow the program to detect that an overflow has occurred. However, in RISC-V it is up to the individual implementation how to handle such overflows, divide by zero, carries and other arithmetic events that might occur when executing instructions. Of course just adding, subtracting or multiplying integers is only going to get us so far. Most programs rely on conditions were a certain set of instructions is only executed if the condition holds. With subsequent assembly instructions the equivalent pseudocode as it could be interrupted in a higher level language such as Java or C is shown beside it.

### Conditional Branches / Jumps

blt a0, a1, .conditional # if(a0 < a1) goto conditional;

Above is the branch less than instruction which jumps to the specified label if the first parameter is less than the second parameter. The third argument is the label to jump to. Labels are declared in assembly programs with specific names so they can be jumped back to later. Efficient assembly code uses small general purpose snippets of labeled code which can be reused many times. This effectively reduces the size of the program although it can sometimes be at the cost of performance. In addition to conditional jump instructions or branch instructions are they are called in RISC-V. There is also the unconditional jump. This instruction will always jump to the specified label unconditionally and in RISC-V it is denoted simply as j.

j .exit # goto exit;

Why labels are more comparable to goto than a function call is because of the assembly instruction call which performs the actual call to functions. Calls are more involved than jumps requiring the correct setup of stack frames and dealing with return data. For now, it is important to know that it exists but basic loops are covered first before dealing with proper functions and their corresponding stack frames.

The final instructions to consider before the first program can be analyzed are the load and store instructions. Known as lw and sw in RISC-V these mean load word and store word respectivelu. Read the following examples below but do not worry if it is not immediately clear how they operate.

sw a0, 0(sp) # store the contents of a0 in the address of sp
lw a0, 0(sp) # load the contents of the address sp into register a0

An important property of a register is that it can be used to store a address in memory. This is known as an reference, subsequently with such a reference we can point to specific addresses in memory. The lw and sw allow to store and load information from registers into these memory references. The example below will show the importance of reading and writing to memory although arguably the most complicated instruction shown yet.

addi sp, zero, 0xff # set the sp register to 0xff in hexadecimal
sw   a0, 0(sp) # use the value 0xff from sp as an memory address to store a0
addi, a0, zero, zero # set register a0 to 0 losing its previous value
lw  a0, 0(sp) # use the value 0xff from sp as memory address to restore a0

This covers all assembly instructions that will subsequently be used in the Ripes simulator. When using this simulator the execution pipeline and results on registers or memory locations can be viewed graphically.

## Installing Ripes

There are multiple methods to install Ripes for most operating systems. By far the simplest method is to download the release from Github. The information in this post will be based on Ripes version 1.0.3 [6].

All the three executables the .exe, app and AppImage can be executed directly. As a result, the download location is up for the end user to decide and afterwards the file can be removed if desired. OSX users are entrusted to be familiar with allowing third party executables to be allowed to run. Similarly, Linux users are expected to know how to set file permissions to make files executable. Now start Ripes and lets get started.

 Ripes simulator processor view

## The First Basic Loop

The first example will entail a basic for loop that will start at 5 and decrement until smaller than 0. At first a minimal assembly representation of this will be covered. Slowly other important aspects that also need to be handled in assembly will be covered.

#pseudo code
for(int i = 5; i > 0; i--) {}

# assembly equivalent
j .loop

.loop:
blt a0, a1, .exit_loop
j .loop

.exit_loop:
...

Before starting to announce improvements lets analyze the assembly shown above. Initially the value 5 is put into the a0 register following 1 being put into a1. Now a unconditional jump is performed to enter .loop. Inside the loop (a0 < a1) is evaluated and if true a jump to .exit_loop is performed. Obviously 5 is not less than 1 so the execution continuous normally. Next a0 is decremented by one and the subsequent jump goes back to the start of the loop. Now 4 is still not less than 1 but the looping pattern has become apparent. When the value in a0 has become 0 it is less than 1 which is in the a1 register and a jump to .exit_loop will be performed. Below the operation of this simple loop is visually demonstrated step-by-step, of course it is encouraged to perform this stepping in Ripes yourself.

## Functions Calls and Stack Frames

Inevitably a program at some point becomes so significantly complex that it would be impossible to keep an overview without functions. Even in assembly the concept of functions is well know, however, in assembly a programmer needs to perform various tasks to ensure a call executes correctly. Before the next two assembly instructions call and ret can be properly introduced, some registers their special purpose has to be described. Lets take a look at the registers sp(x2), ra(x1), s0(x8). Here the labels are no longer of significant value so they will be omitted in the future. It no longer matters that a0 is label x11 for example. Here sp stand for stack pointer, ra stands for return address and s0 or otherwise known as fp stands for frame pointer. The basic purposes of these registers will be explained. However, for a more thorough guide on register conventions one is advised to read Harry H. Porter III his guide [7] starting on page 146.

The return address (ra) is used to return from a call back to were the program was executing instructions before the call. In other architectures such as X86 the return address is stored in main memory. Using registers instead allows the executions of calls to be performed much faster and with lower overhead However, the storing or the return address in main memory can only be avoided if the function makes no subsequent calls to other functions.

### Stack pointer (sp)

The stack pointer (sp) reserves space for calls to store variables in main memory. It must always be modified by multiples of 16 bytes and reserving space must be done by decrementing it. This is very typical for most architectures were variables on the stack and heap are directly opposite from one another. This allows to effectively use the entirety of available memory without variables on the stack overwriting variables on the heap. After the reserving of space by decrementing sp it must be subsequently incremented again by the same amount before returning from the call.

### Frame pointer (a0, fp)

The frame pointer (fp) is not always needed with every call, furthermore, it is likely that most calls won’t need to use the frame pointer. The frame pointer is used to determine offsets for calls that create variables with dynamic sizes. Additionally, a frame pointer is needed when using a large amount local variables due to a limitation in RISC-V on the maximum size of relative offsets. The dynamic use of the frame pointer is outside the scope of this tutorial, however, the value will correctly be incremented and stored in examples.

### Stack frames

Stack frames are sized in 16 bytes chunks, naturally, this makes the smallest possible stack frame 16 bytes large. A stack frame is constructed by decrementing the current value of sp and subsequently storing ra and fp in main memory. The storing of ra and fp is done with a relative offset to sp. Finally fp incremented by the size of the stack frame. When a stack frame is destructed the original value of fp is restored from main memory. Followed by restoring the value of ra. Finally, the value of sp is incremented back up to its original value. Below is an example of the construction and destruction of the most basic stack frame.

# construction
sw      ra, 12(sp)
sw      s0, 8(sp)
# destruction
lw      s0, 8(sp)
lw      ra, 12(sp)

Before putting this all together and introducing the call and ret instructions. Consider the following stack frame that takes one argument and returns this argument after performing an addition with itself. The argument taken is a regular 32bit integer and all operations with this argument use the a0 register. Upon careful inspection of the assembly instructions it can be observed that many of the sw and lw instructions could be optimized away. Partly this is the job of the compiler but also of the programmer. Writing return num + num; would have removed almost all of the sw and lw instructions shown below for example.

#pseudo code
int sum(int num) {
num += num;
return num;
}

# construction
sw      ra, 12(sp)
sw      s0, 8(sp)
# store first argument
sw      a0, -12(s0)
# addition of a0 + a0
lw      a0, -12(s0)
sw      a0, -12(s0)
# destruction
lw      a0, -12(s0)
lw      s0, 8(sp)
lw      ra, 12(sp)

### Function Calls

The fundamental understanding of critical registers as well as the stack frames allows to define complete functions which can be called in assembly. The call instruction is similar to the jump in that it will jump to a label, however, it expects the subsequent instructions to properly construct and destruct a stack frame. When the destruction of the stack frame is completed the ret instruction should be called. This instruction will ensure that execution continues from were the call was made. To demonstrate consider the same example as previously but now with appropriate function calls.

int sum(int num) {
num += num;
return num;
}

int main(int argc, char** argv) {
return sum(5);
}

From main the sum function is called with the integer value 5 as it’s first argument. For simplicity, let’s show the resulting assembly without the construction and destruction of the main stack frame. Instead focus on how call and ret are used to jump to parts of the assembly code.

sum(int):
sw      ra, 12(sp)
sw      s0, 8(sp)
sw      a0, -12(s0)
lw      a0, -12(s0)
sw      a0, -12(s0)
lw      a0, -12(s0)
lw      s0, 8(sp)
lw      ra, 12(sp)
ret

main:
...
call    sum(int)
...
ret

Before calling the sum function the literal 5 is stored in register a0. This is because a0 is the first argument by convention. Now call will jump to the sum(int): label and start executing instructions from there. In sum it can be seen that a0 is assumed to contain the value for the first argument because of the sw a0, -12(s0) instruction. Naturally, the following lw a0, -12(s0) instruction is redundant and only placed by the compiler if the -O flag is set to zero. The keen eyed might notice the compiler has still managed to sneak one optimization into the assembly as the return value after the call to sum is assumed to still be in a0 when the main calls ret.

## Simulating Function Calls in Ripes

When observing the resulting assembly in Ripes the call and ret instructions no longer exist. This is because these instructions are converted by the assembler depending on the addressing mode [8]. The most common mode is called PC-relative and this uses relative offsets from the program counter pc current address. This special register is only accessible through specific instructions as is shown later.

With the first call to sum the instruction is translated into two separate instructions. These instructions are auipc x6, 0 and jalr x1, x6, 24. Firstly let’s translate the registers to the names we have used throughout this post, these now become auipc t1, 0 and jalr ra, t1, 24. Here auipc stores the pc register in t1 with an additional offset of 0. The jalr instruction jumps to t1 + 24 and stores this address + 4 in ra. The +4 is needed so that upon returning the jalr instruction is not executed again. While the 24 is the relative distance between the auipc instruction and the start of .sum:. The special auipc register allows to store the current value of the program counter pc in a general purpose register such as ra.

The ret calls are translated to jalr x0, x1, 0 since this will jump back to the address stored in x1 / ra. The return value of jalr is stored in the unchangeable x0 register since there is no desire to modify any registers upon returning.

Although, it is important to understand that the call and ret instructions are actually translated into separate instructions that differ per memory model. The underlying instructions used to facilitate these instructions are typically not shown in a disassembly or while assembling.

## Compiler Optimizations

As a final note, an example of the incredible optimizations compilers are able to generate is shown. The same c code were the sum of 5 is computed in a function is used but now the compiler -O0 flag is changed to -O3.

sum(int):
slli a0, a0, 1
ret
main:


text:
# How To Size A Pump

To size a pump, you must define:

• The flow rate of liquid the pump is required to deliver
• The total differential head the pump must generate to deliver the required flow rate

This is the case for all types of pumps: centrifugal or positive displacement.

Other key considerations for pump sizing are the net positive suction head available (NPSHa) and the power required to drive the pump.

### Flow Rate

Usually, the flow rate of liquid a pump needs to deliver is determined by the process in which the pump is installed.  This ultimately is defined by the mass and energy balance of the process.

For instance the required flow rate of a pump feeding oil into a refinery distillation column will be determined by how much product the column is required to produce.  Another example is the flow rate of a cooling water pump circulating water through a heat exchanger is defined by the amount of heat transfer required.

The total differential head a pump must generate is determined by the flow rate of liquid being pumped and the system through which the liquid flows.

Essentially, the total differential head is made up of 2 components.  The first is the static head across the pump and the second is the frictional head loss through the suction and discharge piping systems.

The discharge static head is sum of the gas pressure at the surface of the liquid in the discharge vessel (expressed as head rather than pressure) and the difference in elevation between the outlet of the discharge pipe, and the centre line of the pump.

Discharge static head = Discharge vessel gas pressure head + elevation of discharge pipe outlet – elevation of pump centre line

The discharge pipe outlet may be above the surface of the liquid in the discharge vessel or it may be submerged as shown in these 3 diagrams.

The suction static head is sum of the gas pressure at the surface of the liquid in the suction vessel (expressed as head rather than pressure) and the difference in elevation between the surface of the liquid in the suction vessel and the centre line of the pump.

Suction static head = Suction vessel gas pressure head + elevation of suction vessel liquid surface – elevation of pump centre line

Note: gas pressure can be converted to head using: Gas head = gas pressure ÷ (liquid density x acceleration due to gravity)

The total frictional head losses in a system are comprised of the frictional losses in the suction piping system and the frictional losses in the discharge piping system.

Frictional head losses = frictional losses in suction piping system + frictional losses in discharge piping system

The frictional losses in the suction and discharge piping systems are the sum of the frictional losses due to the liquid flowing through the pipes, fittings and equipment.  The frictional head losses are usually calculated from the Darcy-Weisbach equation using friction factors and fittings factors to calculate the pressure loss in pipes and fittings.

Darcy-Weisbach equation:

$$\text{Frictional head losses} = \left( f \frac{L}{D} + K_{fittings} \right) \frac {u^2}{2g}$$

Where:

$$f =$$ pipe friction factor
$$L =$$ pipe length
$$D =$$ pipe diameter
$$K_{fittings} =$$ fittings factor
$$u =$$ liquid velocity
$$g =$$ acceleration due to gravity

In order to calculate the frictional head losses you therefore need to know the lengths and diameters of the piping in the system and the number and type of fittings such as bends, valves and other equipment.

## Net Positive Suction Head Available

The net positive suction head available (NPSHa) is the difference between the absolute pressure at the pump suction and the vapour pressure of the pumped liquid at the pumping temperature.

It is important because for the pump to operate properly, the pressure at the pump suction must exceed the vapour pressure for the pumped fluid to remain liquid in the pump.  If the vapour pressure exceeds the pressure at the pump suction, vapour bubbles will form in the liquid.  This is known as cavitation and leads to a loss of pump efficiency and can result in significant pump damage.

To ensure that the pump operates correctly the net positive suction head available (NPSHa) must exceed the net positive suction head required (NPSHr) for that particular pump.  The NPSHr is given by the pump manufacturer and is often shown on the pump curve.

Net positive suction head available = absolute pressure head at the pump suction – liquid vapour pressure head

## Pump Power

Pumps are usually driven by electric motors, diesel engines or steam turbines.  Determining the power required is essential to sizing the pump driver.

Pump power = flow rate x total differential head x liquid density x acceleration due to gravity ÷ pump efficiency

## How To Size A Pump Example

Let’s look at an example to demonstrate how to size a pump.

30000 kg/hr of water needs to be pumped from one vessel to another through the system shown in the diagram below.  The water is at 20C, has a density of 998 kg/m3 , a vapour pressure of 0.023 bara and a viscosity of 1cP.  We’ll assume that the pump efficiency is 70%.

### Calculation

The calculation is presented below:

### Results

Pump flow rate = 30 m3/hr
Pump total differential head = 134.8 m
Net positive suction head available = 22.13 m
Pump power = 15.7 kW


text:
# Is it possible to see light intensity fluctuate?

Solutions to Maxwell's equations shows that the $\vec{E}$ and $\vec{H}$ component are of the same phase, which means they go to maximum and zero together, therefore the intensity of the electromagnetic wave should be 'lumpy'.

My first question is, if I have a fast enough light intensity detector, or say detecting low frequency like radio wave, can I see the fluctuation in the signal of intensity?

I always think it is reasonable to observe that, until I learned in quantum field theory, that telling me electromagnetic interactions obey the phase gauge transform invariance, phase is always relative, absolute phase is not observable.

Why absolute phase is not observable? Of course we can see the absolute phase in alternating current, so I'm confused, what is the quantum field theory trying to imply?

UPDATE:

For the second question, it looks like I'm mixing up the complex amplitude in optics and the wave function in quantum mechanics, complex amplitude $u=e^{i\varphi}$ is actually a representation for $\cos \varphi$, while wave function $\psi=e^{i\varphi}$ doesn't have a meaning because only the $|\psi|^2$ is observable.

In theory, it should be (lumpy), however:

Even if you could observe the peaks, or nodes and antinodes of the EM vectors of a single photon, its energy would be absorbed by the instrument you employed to observe it. Fast enough doesn't cut it. If the instrument absorbs no energy from the photon, it will also not be detected.

Intensity for light is not just the amplitude of a single photon. It is the superposition average of the intensities (amplitudes) of lots of photons. Even a laser will have limitations depending on spatial and temporal coherence, which is to say, all of the photons emitted will also not go to zero amplitude at exactly the same location or time.

Your first question (and in part, the second) reveals a possible philosophical problem you have: you think that Maxwell's equations (or any other mathematical expression) is The Absolute Law that the Nature follows. It does not. Instead, we invent models that can describe (to a certain accuracy) how stuff around us behaves. It's not the Nature that obeys our equations, it is our models are adequate enough to describe the Nature. Think about it.

As to the second part of your question - you can observe the phase (or at least the influence of it), and measure it using wavefront sensors such as Shack-Hartmann or Curvature sensor. You can see the phase inhomogeneity when looking on stars at night - they are twinkling because of the atmosphere turbulence.

Consider the wavefront as a complex matrix $U_{out} = A e^{- i \phi }$ with the amplitude $A = |U_{out}|$ in W/m$^2$ and the phase $\phi = tan^{-1} \frac{imag(U_{out})}{real(U_{out})}$. Using something like Shack-Hartmann wavefront sensor, you can estimate the phase, that is, the $\phi$ in $U_{out} = A e^{- i \phi }$.

• +1 Great answer - especially for the mention of the wavefront sensors. However, for completeness, it might be good to point out that measurements are invariant to the light field's scaling by any global pure phase $e^{i\,\alpha}$. – WetSavannaAnimal Sep 30 '15 at 12:18

In principle, you should be able to detect the nodes and anti-nodes of the light, provided that:

• you are in a classical limit, with enough photons detected per period to make the quantization irrelevant
• your “light” is actually an electromagnetic wave of low frequency, low enough for your detector to see the individual bumps.

This ends up being quite close to your example of seeing the phase of the AC current. You can do the same thing with higher frequency waves as long as your electronics is fast enough.


text:
Free cookie consent management tool by TermsFeed Policy Generator

# source:stable/HeuristicLab.Problems.GeneticProgramming.Views/3.3/Plugin.cs.frame

Last change on this file was 17186, checked in by swagner, 3 years ago

#2875: Merged r17182:17185 from trunk to stable

File size: 2.0 KB
Line
1#region License Information
2/* HeuristicLab
3 * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
24using System.Text;
25using HeuristicLab.PluginInfrastructure;
26
27namespace HeuristicLab.Problems.GeneticProgramming.Views {
28  [Plugin("HeuristicLab.Problems.GeneticProgramming.Views","Provides views for for genetic programming problems such as the artificial ant problem.", "3.3.16.$WCREV$")]
29  [PluginFile("HeuristicLab.Problems.GeneticProgramming.Views-3.3.dll", PluginFileType.Assembly)]
30  [PluginDependency("HeuristicLab.Common","3.3")]
31  [PluginDependency("HeuristicLab.Common.Resources","3.3")]
32  [PluginDependency("HeuristicLab.Collections","3.3")]
33  [PluginDependency("HeuristicLab.Core","3.3")]
34  [PluginDependency("HeuristicLab.Core.Views","3.3")]
35  [PluginDependency("HeuristicLab.Data","3.3")]
36  [PluginDependency("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding","3.4")]
37  [PluginDependency("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views","3.4")]
38  [PluginDependency("HeuristicLab.MainForm","3.3")]
39  [PluginDependency("HeuristicLab.MainForm.WindowsForms","3.3")]
40  [PluginDependency("HeuristicLab.Problems.GeneticProgramming","3.3")]
41  public class HeuristicLabProblemsGeneticProgrammingViewsPlugin : PluginBase {
42  }
43}
Note: See TracBrowser for help on using the repository browser.


text:
# Control Charts-R

#### yon

##### New Member
hi, I'm trying to get the Control charts for the following scenarios:

a)An electronics company manufactures several types of cathode-ray tubes on a mass production basis. To monitor the process, 50 tubes of a certain type were randomly sampled from the production line and inspected each day over a period of 21 days.

I got the control chart using command qcc( crt, "type =c")
group 1 and 9 are out of control, but i can't take them out of analysis.
when I go qcc(crt[-1], type="c") i get an error, and i don't know how to delete both of the "out of control" values!

heres the txt file for this problem:
Code:
day no.defective sample.size
1 11 50
2 15 50
3 12 50
4 10 50
5 9 50
6 12 50
7 12 50
8 14 50
9 9 50
10 13 50
11 15 50
12 23 50
13 15 50
14 12 50
15 11 50
16 11 50
17 16 50
18 15 50
19 10 50
20 13 50
21 12 50
b)
A corporation that manufactures field rifles for the Department of Defence operates
a production line that turns out finished firing pins. To monitor that process,
an inspector randomly selects five firing pins from the production line, measures
their lengths (in inches) and repeats this process at 30-minute intervals over a
5-hour period.
I divide it into 5 sub groups using:
gps <- qcc.groups(maple, rep(1:10, each=5))
but it says: Error in qcc.groups(maple, rep(1:10, each = 5)) :
data and sample must be vectors of equal length
i really don't know what i'm to do with this one.

heres the txt file for the data
Code:
length interval
1.05 1
1.03 1
0.99 1
1 1
1.03 1
0.93 2
0.96 2
1.01 2
0.98 2
0.97 2
1.02 3
0.99 3
0.99 3
1 3
0.98 3
0.98 4
1.01 4
1.02 4
0.99 4
0.97 4
1.02 5
0.99 5
1.04 5
1.07 5
0.98 5
1.05 6
0.98 6
0.96 6
0.91 6
1.02 6
0.92 7
0.95 7
1 7
0.99 7
1.01 7
1.06 8
0.98 8
0.98 8
1.04 8
1 8
0.97 9
0.99 9
0.99 9
0.98 9
1.01 9
1 10
0.96 10
1.02 10
1.03 10
0.99 10
any help is really appreciated.
thanks


text:
# Math Help - Stumped on a simple harmonic motion question

1. ## Stumped on a simple harmonic motion question

$mg = k\Delta\l$
And I obtained 5314 N/m.
After that, I calculated $v_{max}$ by using:
$v_{max} = A\sqrt{\frac{k}{m}}$

2. Originally Posted by xxlvh
A proud deep-sea fisherman hangs a 65.0 kg fish from an ideal spring having negligible mass. The fish stretches the spring 0.120 m. The fish is now pulled down 5.00 cm and released. What is the maximum velocity it will reach?

No idea where I am going wrong here. First, I solved for the spring constant:
$mg = k\Delta\l$
And I obtained 5314 N/m.
After that, I calculated $v_{max}$ by using:
$v_{max} = A\sqrt{\frac{k}{m}}$
With 0.17 m as the Amplitude and I got 1.54 m/s as the answer, which is incorrect. I also tried using conservation of energy formulas, only to get the same answer. Can anyone help me out??
$k = \frac{mg}{\Delta x} = \frac{65 \cdot 9.8}{.12} = 5308.3$ N/m

the fish is pulled down 5.0 cm = 0.05 m down from equilibrium ...

$A = 0.05$ m

amplitude is measured from equilibrium, not the unstretched position of the spring.

$v_{max} = A\omega = 0.05\sqrt{\frac{5308.3}{65}}$

3. Yiikes I need to pay closer attention. Thank you very much!


text:
# Calculating expected return

Assume I have a trading system that I'm evaluating over a three-year period. The returns are 25%, -40% and 25%. Empirically, I can see that this system loses because at the end of three years, I have less than when I started.

Wikipedia defines expected return as follows:

E(R)= Sum: probability (in scenario i) * the return (in scenario i)

If we insert our values into this formula, we get the following:

E(R) = (.33 * .25) + (.33 * -.40) + (.33 * .25) = .033

So a positive expected return for a system that loses every time, no matter if you re-arrange the order of the returns.

What's wrong here?

To further explain how the game works, consider an initial start value of 100. What can you expect at the end of the game? There are no re-investments, no withdrawls, no dividends, no broker fees nor SEC fees. It is a simple game. Here is some R code to illustrate the game.

first  <- c(.25, .25, -.4)
second <- c(-.4, .25, .25)
third  <- c(.25, -.4, .25)

Pass any of the above sequence of returns into this function:

game <- function(x){

start <- 100

for(i in 1:NROW(x))

start <- start + start*x[i]

return(start)
}

NOTE: I asked a similar question on quantexchange, but I'm interested here in the math behind the expected return equation.

The difference between the two ways to look at the return is whether you are reinvesting your gains. If you start with 100 dollars and reinvest all of the money the next year, your balances will be: 125, 75, 93.75 dollars - you lost money. However if you invest 100 dollars every year, then you get +25 - 40 +25 = +10 dollars gain. That's one way you could think about the Wikipedia formula. A better way to interpret it, though, is that you are investing in one of the three years chosen at random, and it gives you the expected return.

• So my error is not re-upping during losing years and taking profits on winning years? Apr 21 '11 at 14:23
• @Milk It's not that simple. Suppose you invest 100 dollars. After year 1, you take 25 out, leaving 100. After year 2, you have lost 40, so you put the \$25 back in plus another 15. After year 3, you have 125. In toto you were forced to have 115 in cash (not 100), on which you made only 10 after 3 years. All this assumes you cannot earn interest on the unused cash sitting around and you cannot borrow money. This only begins to hint at the mistakes that will be made when using oversimplified formulas for expectation. Reading a good text on financial calculus will serve you well.
– whuber
Apr 21 '11 at 18:48
• @Milk An excellent starting point is Stochastic Calculus for Finance; Volume I: The Binomial Asset Pricing Models by Steven E. Shreve, Springer-Verlag, New York, 2005.
– whuber
Apr 21 '11 at 18:50
• I'm accepting this but need to say the wiki equation is awkward at best. It's application to trading is limited. There are other expected return formulae that are better suited to examine trade system characteristics. Apr 22 '11 at 0:18

Wikipedia is right. So are your calculations: this system should win.

However: it also assumes that your investments in each part are equal in size (because you give equal probability 1/3 to each). If this is not true, that may explain the difference with your empirical observations (perhaps you should share the numbers with us on those). e.g. If you invested twice as much in the part that has a negative return than in the two other parts, the probabilities become 1/4,1/2,1/4 and you'd have a losing system.

This is also ignoring any extra costs, so if these extra costs are bigger than your meager (?) 1/30 return, this could be another explanation (I'm not familiar with the practicalities of trading).

• I've included some R code by way of explanation. So you're saying I'm not applying the wiki formula correctly? Presumably by assigning the probabilities, no? Apr 21 '11 at 14:20
• Now I see: you did not divide your initial amount into three parts (that is what the Wikipedia formula would be for), the three returns are just the returns each year. In your case, the formula is simply ((100(1+0.25))(1-0.4))(1+0.25). There is no probability involved in this way. Apr 21 '11 at 14:29


text:
# publicsagemath/sagenb

### Subversion checkout URL

You can clone with HTTPS or Subversion.

Fetching contributors…

Cannot retrieve contributors at this time

file 25 lines (23 sloc) 0.283 kb
 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 # Boring file regexps:*.scssc*.sassc*~/.hg/.hgtags*.orig*.patch*.pyc*.pyo/*.gitk-tmp*# sage files to ignore:/build/distMANIFESTPKG-INFOrelease_notes.txt/sass/src/.sass-cache/sagenb/data/jmol/sagenb.egg-infosagenb/data/jsmath/fontssagenb/data/MathJax/setup.cfg
Something went wrong with that request. Please try again.


text:
Which country has a decreasing population? By what percentage us the population of that country decreasing each year?

India: $A = 1049.7 {e}^{0.015} t$ Iraq: $A = 24.7 {e}^{0.028} t$ Japan: $A = 127.2 {e}^{0.001} t$ Russia: $A = 144.5 {e}^{-} 0.004 t$

Apr 26, 2018

Russia is the only one with a decreasing population curve. It is decreasing at a rate of 0.40%

Explanation:

Russia is the only expression with a negative in the exponential term, indicating a decrease. To find the percentage decrease you can calculate the value for two different years.

A=144.5e^(−0.004t)

A_1=144.5e^(−0.004) = 143.92

A_2=144.5e^(−0.008) = 143.35

The percent change is thus:
$\frac{143.92 - 143.35}{143.92} = 0.00397$
100 xx 0.00397 = 0.40%


text:
{{ item.displayTitle }}
navigate_next
No history yet!
Progress & Statistics equalizer Progress expand_more
Student
navigate_next
Teacher
navigate_next
{{ filterOption.label }}
{{ item.displayTitle }}
{{ item.subject.displayTitle }}
arrow_forward
To calculate a power means to evaluate its value. For example is $2^3=8$ since it's a product with three twos as factors. Remember that any number raised to the power of $1$ is the base itself, and any non-zero number raised to the power of $0$ is $1.$ \begin{aligned} 2^3=8\\ 4^1=4\\ 74^0=1 \end{aligned}


text:
# Synopsis: Winding up with a better clock

New measurements have pinned down the frequency of a long-lived optical transition in ytterbium with the potential for better atomic clocks.

Today’s best timepieces are atomic clocks that rely on measurements of microwave transitions in cesium atoms, with a precision such that more than 60 million years would pass before the clock gained or lost a second. Current clock research is focused on moving to optical transitions, so that atomic clocks could be made smaller, cheaper, and even more reliable.

One route to getting to the frequency uncertainty range of ${10}^{-17}$ required for an optical primary time standard is to study long-lived narrow linewidth transitions in laser-cooled ions or neutral atoms. A team from the National Physical Laboratory, Oxford University, and Imperial College London in the UK report in Physical Review A their precision measurements of laser-cooled single ytterbium ions, which improve our knowledge of the key optical transition by a factor of 50.

To achieve this feat, the researchers loaded individual ytterbium ions into a trap, cooled each ion with laser beams, then pumped and probed the optical clock transition at 467 nm. By paying close attention to the accurate alignment of the lasers and ensuring high mechanical stability, Hosaka et al. were able to obtain the frequency of this extremely weak dipole-forbidden transition with an uncertainty of 2 x ${10}^{-14}$. The team predicts that with further improvements to the probe laser stability and temperature control, they should be able to achieve a short-term uncertainty of ${10}^{-15}$ and a stability of ${10}^{-17}$ averaged over long times. - David Voss

### Announcements

More Announcements »

## Subject Areas

Atomic and Molecular Physics

Magnetism

Nanophysics

## Related Articles

Condensed Matter Physics

### Viewpoint: An Arrested Implosion

The collapse of a trapped ultracold magnetic gas is arrested by quantum fluctuations, creating quantum droplets of superfluid atoms. Read More »

Atomic and Molecular Physics

### Synopsis: No Vacancy for Tunneling

The tunneling rate for cold atoms in an optical lattice can be made to depend on whether a neighboring site is occupied—a behavior that may reflect the tunneling in complex materials. Read More »

Atomic and Molecular Physics

### Viewpoint: Next Generation Clock Networks

Free-space laser links have been used to synchronize optical clocks with an unprecedented uncertainty of femtoseconds. Read More »


text:
speeding up matrix multiplication (newbie question)
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
 Date: -- (:) From: Will M. Farr Subject: Re: [Caml-list] speeding up matrix multiplication (newbie question)
Erick,

Sorry about the long email, but here is an explanation of what
"boxing" means, how it slows you down in this case, and how you can
(eventually) figure out whether it will slow you down in general.  I'm
not an expert, so I've probably made mistakes in the following, but I
think the broad outlines are correct.  True experts can weigh in to
correct me.

Due to polymorphism (i.e. the fact that one must be able to stuff
*any* ocaml value into an 'a list), every ocaml value must have a
uniform format and size if it is possible that it can be used
polymorphically.  The current compiler can prove in certain cases that
a value is not used polymorphically; when this is possible, the value
can be stored more efficiently.  For example, in the expression:

let f a b =
let x = a *. b in
3.0 *. x

the compiler can tell that x is always going to be used as a float and
not polymorphically.  However, a, b, and (3.0 *. x) can escape to the
larger world, where they could potentially be used polymorphically,
and therefore need to have the uniform representation.

It turns out that the representation chosen for the OCaml runtime is a
32-bit integer (i.e. a pointer).  So, to represent a float that can be
used polymorphically, the runtime allocates 64-bits of memory, stuffs
the float into it, and uses the pointer to the memory to represent the
float in the program.  This procedure is called "boxing".  In the case
above, the contents of x can be represented "unboxed" as a real 64-bit
floating point number, while the contents of a and b, and the result
(3.0 *. x) must be boxed.

The boxing rules for the ocaml compiler are described at
http://caml.inria.fr/pub/old_caml_site/ocaml/numerical.html (I don't
know if this is current or not).  The relevant rules for analyizing
your code are probably a) no cross-module inlining of functor argument
functions (i.e. N.add, N.mul, etc), b) boxing of floats at all
(non-inlined) function boundaries, and c) floating point arrays store
their elements unboxed.  There are other rules, given at the above
website.

So, the code you wrote

result.(i) <- N.add result.(i) (N.mul (get m i j) v.(j))

allocates a box for the result of (get m i j) (unless this procedure
is inlined, which is possible if it's short, and not coming in via
functor argument---it would be better to use m.(i).(j) if possible),
another box for v.(j), passes them to N.mul, which allocates a box for
the result of the multiplication.  Then a box is allocated for
result.(i), and the previous result and result.(i) are passed to
N.add, which allocates a box for its result.  Then this box is opened
and the value in it is stored in result.(i).  Ugh.  If, instead, you
write

result.(i) <- result.(i) +. (get m i j)*.v.(j)

there is *at most* one box for (get m i j).  If we assume that (get m
i j) is inlined and therefore the boxing overhead is eliminated, the
entire process takes only a few clock cycles.  Compare to possibly
several hundred or more clock cycles above, plus the extra stress on
the GC from collecting all the boxes when they are no longer

In short, you'll get a lot faster if you specialize the operations to
floats.  Like order-of-magnitude or greater speedups.

Good luck!

Will

On Fri, Feb 20, 2009 at 2:53 PM, Erick Matsen <matsen@berkeley.edu> wrote:
> Wow, once again I am amazed by the vitality of this list. Thank you
>
> Here is the context: we are interested in calculating the likelihood
> of taxonomic placement of short "metagenomics" sequence fragments from
> unknown organisms in the ocean. We start by assuming a model of
> sequence evolution, which is a reversible Markov chain. The taxonomy
> is represented as a tree, and the sequence information is a collection
> of likelihoods of sequence identities. As we move up the tree, these
> sequences "evolve" by getting multiplied by the exponentiated
> instantaneous Markov matrix.
>
> The matrices are of the size of the sequence model: 4x4 when looking
> at nucleotides, and 20x20 when looking at proteins.
>
> The bottleneck is (I mis-spoke before) that we are multiplying many
> length-4 or length-20 vectors by a collection of matrices which
> represent the time evolution of those sequences as follows.
>
> Outer loop:
>  modify the amount of time each markov process runs
>  exponentiate the rate matrices to get transition matrices
>
>  Recur over the tree, starting at the leaves:
>    at a node, multiply all of the daughter likelihood vectors together
>    return the multiplication of that product by the trasition matrix
> (bottleneck!)
>
> The trees are on the order of 50 leaves, and there are about 500
> likelihood vectors done at once.
>
> All of this gets run on a big cluster of Xeons. It's not worth
> parallelizing because we are running many instances of this process
> already, which fills up the cluster nodes.
>
> So far I have been doing the simplest thing possible, which is just to
> multiply the matrices out like \sum_j a_ij v_j. Um, this is a bit
> embarassing.
>
> let mul_vec m v =
>    if Array.length v <> n_cols m then
>      failwith "mul_vec: matrix size and vector size don't match!";
>    let result = Array.create (n_rows m) N.zero in
>    for i=0 to (n_rows m)-1 do
>      for j=0 to (n_cols m)-1 do
>        result.(i) <- N.add result.(i) (N.mul (get m i j) v.(j))
>      done;
>    done;
>    result
>
> I have implemented it in a functorial way for flexibility. N is the
> number class. How much improvement might I hope for if I make a
> dedicated float vector multiplication function? I'm sorry, I know
>
>
> Thank you again,
>
> Erick
>
>
>
> On Fri, Feb 20, 2009 at 10:46 AM, Xavier Leroy <Xavier.Leroy@inria.fr> wrote:
>>> I'm working on speeding up some code, and I wanted to check with
>>> someone before implementation.
>>>
>>> As you can see below, the code primarily spends its time multiplying
>>> relatively small matrices. Precision is of course important but not
>>> an incredibly crucial issue, as the most important thing is relative
>>> comparison between things which *should* be pretty different.
>>
>> You need to post your matrix multiplication code so that the regulars
>> on this list can tear it to pieces :-)
>>
>> From the profile you gave, it looks like you parameterized your matrix
>> multiplication code over the + and * operations over matrix elements.
>> This is good for genericity but not so good for performance, as it
>> will result in more boxing (heap allocation) of floating-point values.
>> The first thing you should try is write a version of matrix
>> multiplication that is specialized for type "float".
>>
>> Then, there are several ways to write the textbook matrix
>> multiplication algorithm, some of which perform less boxing than
>> others.  Again, post your code and we'll let you know.
>>
>>> Currently I'm just using native (double-precision) ocaml floats and
>>> the native ocaml arrays for a first pass on the problem.  Now I'm
>>> thinking about moving to using float32 bigarrays, and I'm hoping
>>> that the code will double in speed. I'd like to know: is that
>>> realistic? Any other suggestions?
>>
>> It won't double in speed: arithmetic operations will take exactly the
>> same time in single or double precision.  What single-precision
>> bigarrays buy you is halving the memory footprint of your matrices.
>> That could result in better cache behavior and therefore slightly
>> better speed, but it depends very much on the sizes and number of your
>> matrices.
>>
>> - Xavier Leroy
>>
>
> _______________________________________________
> Caml-list mailing list. Subscription management:
> http://yquem.inria.fr/cgi-bin/mailman/listinfo/caml-list
> Archives: http://caml.inria.fr
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs
>


text:
GMAT Question of the Day - Daily to your Mailbox; hard ones only

 It is currently 23 Oct 2018, 07:02

GMAT Club Daily Prep

Thank you for using the timer - this advanced tool can estimate your performance and suggest more practice questions. We have subscribed you to Daily Prep Questions via email.

Customized
for You

we will pick new questions that match your level based on your Timer History

Track

every week, we’ll send you an estimated GMAT score based on your performance

Practice
Pays

we will pick new questions that match your level based on your Timer History

A closed cylindrical tank contains 20*(pi) cubic feet of

Author Message
TAGS:

Hide Tags

Retired Moderator
Status: 2000 posts! I don't know whether I should feel great or sad about it! LOL
Joined: 04 Oct 2009
Posts: 1211
Location: Peru
Schools: Harvard, Stanford, Wharton, MIT & HKS (Government)
WE 1: Economic research
WE 2: Banking
WE 3: Government: Foreign Trade and SMEs
A closed cylindrical tank contains 20*(pi) cubic feet of  [#permalink]

Show Tags

15 Feb 2012, 09:08
4
00:00

Difficulty:

45% (medium)

Question Stats:

67% (02:04) correct 33% (02:37) wrong based on 146 sessions

HideShow timer Statistics

A closed cylindrical tank contains 20*(pi) cubic feet of water and is filled to half its capacity. When the tank is placed upright on its circular base on level ground, the height of the water in the tank is 5 feet. When the tank is placed on its side on level ground, what is the height, in feet, of the surface of the water above the ground?
(Note: "pi" is the constant to calculate the area in a circle. Does someone know its code in the keyboard?)

(A) 1
(B) 1.5
(C) 2
(D) 2.5
(E) 3

Enjoy it as much as I did

Source: Jeff Sackmann problems - http://www.gmathacks.com

_________________

"Life’s battle doesn’t always go to stronger or faster men; but sooner or later the man who wins is the one who thinks he can."

My Integrated Reasoning Logbook / Diary: http://gmatclub.com/forum/my-ir-logbook-diary-133264.html

GMAT Club Premium Membership - big benefits and savings

Manager
Status: Employed
Joined: 17 Nov 2011
Posts: 82
Location: Pakistan
GMAT 1: 720 Q49 V40
GPA: 3.2
WE: Business Development (Internet and New Media)
Re: Beautiful question - Just common sense!  [#permalink]

Show Tags

15 Feb 2012, 09:21
1

Half the capacity $$=20{\pi}$$ cubic feet
So Full Capacity $$=40{\pi}$$ cubic feet

Half the Length $$=5$$ feet
So Full Length $$=10$$ feet

Volume of Cylinder $$={\pi}r^2h$$
$$h=10$$
So $${\pi}r^2h=40{\pi}$$
So $${\pi}r^2*(10)=40{\pi}$$
So $$r^2=4$$
So $$r=2$$

Lying on the ground, water should be half the way up the cylinder, since the cylinder is half full so technically it is as high above the ground as the radius which is $$2$$

Hence C
_________________

"Nowadays, people know the price of everything, and the value of nothing." Oscar Wilde

Math Expert
Joined: 02 Sep 2009
Posts: 50058
Re: A closed cylindrical tank contains 20*(pi) cubic feet of  [#permalink]

Show Tags

15 Feb 2012, 10:26
1
metallicafan wrote:
A closed cylindrical tank contains 20*(pi) cubic feet of water and is filled to half its capacity. When the tank is placed upright on its circular base on level ground, the height of the water in the tank is 5 feet. When the tank is placed on its side on level ground, what is the height, in feet, of the surface of the water above the ground?
(Note: "pi" is the constant to calculate the area in a circle. Does someone know its code in the keyboard?)

(A) 1
(B) 1.5
(C) 2
(D) 2.5
(E) 3

Enjoy it, just as I did

Source: Jeff Sackmann problems - http://www.gmathacks.com

Since the tank is half full when placed upright then it will also be half full when placed on its side, so the level of the water will be half of the diameter, so r.

Now, given that $$V_{water}=\pi{*r^2}*H_{water}$$ --> $$20\pi=\pi{r^2}*5$$ --> $$r=2$$.

_________________
Manager
Joined: 24 Dec 2016
Posts: 92
Location: India
Concentration: Finance, General Management
WE: Information Technology (Computer Software)
Re: A closed cylindrical tank contains 20*(pi) cubic feet of  [#permalink]

Show Tags

05 Mar 2017, 22:59
metallicafan wrote:
A closed cylindrical tank contains 20*(pi) cubic feet of water and is filled to half its capacity. When the tank is placed upright on its circular base on level ground, the height of the water in the tank is 5 feet. When the tank is placed on its side on level ground, what is the height, in feet, of the surface of the water above the ground?
(Note: "pi" is the constant to calculate the area in a circle. Does someone know its code in the keyboard?)

(A) 1
(B) 1.5
(C) 2
(D) 2.5
(E) 3

Enjoy it as much as I did

Source: Jeff Sackmann problems - http://www.gmathacks.com

Alt + 227 is the code for Pi.
Non-Human User
Joined: 09 Sep 2013
Posts: 8541
Re: A closed cylindrical tank contains 20*(pi) cubic feet of  [#permalink]

Show Tags

21 Sep 2018, 07:23
Hello from the GMAT Club BumpBot!

Thanks to another GMAT Club member, I have just discovered this valuable topic, yet it had no discussion for over a year. I am now bumping it up - doing my job. I think you may find it valuable (esp those replies with Kudos).

Want to see all other topics I dig out? Follow me (click follow button on profile). You will receive a summary of all topics I bump in your profile area as well as via email.
_________________
Re: A closed cylindrical tank contains 20*(pi) cubic feet of &nbs [#permalink] 21 Sep 2018, 07:23
Display posts from previous: Sort by


text:
## Basic Syntax

[Link Text](link-address)

Protocols like http:// cannot be ommited for this type of syntax.

[Link Text][Ref]

or, it can be shorten as

[Ref][]

Protocols like http:// cannot be ommited for this type of syntax.

<http://typora.io>

#### Auto URL

Typora can automatically detect url link in markdown, and render them as URL link, but please note that other markdown engines may not support this.

This is a link: http://typora.io

#### HTML  tag

Link to Google

 Anchor

For link towards a website, we suggest you DO NOT ommit URL protocols like https:// or http://, or it may be interrucpt as relative link by Typora or other Markdown egines, or after export/publish.

You could use write relative or absolute path as link address towards a local file, the extension like (.md) can be omitted, for example:

[Readme1](Readme1.md)

Please note that, for relative link address, it will not be converted into real absolute file path when export as HTML based on Markdown’s spec.

You can use # to create links towards any headings in your markdown file, for example:

# This is a title

...
...
...

You could also write named anchors using raw HTML:

 Anchor

To, hide the empty , you could add following in custom CSS (#2921):

/* hide the anchor HTML */
a[name]:empty + .md-raw-inline {
display:none;
}
a[name]:empty {
text-decoration: none;
}
a[name]:empty:before {
content:"⚓";
}
/* show the anchor HTML when cursor is inside */
.md-expand .md-raw-inline {
display: inline !important;
}

You can use command+click (macOS), or ctrl+click (Linux/Windows) on links in Typora to jump to target headings, or open them in Typora, or open in related apps.

## FAQ

If you want to make a link to local file abd.com, please make ensure the path is correct.

If you want to create a link towards website “abc.com”, you need to put the URL scheme or protocol, for example use [link](http://abc.com).

Sometimes, protocol can be omitted if you use autolink (<www.google.com>) or auto URL (www.google.com), but this rules variables across different Markdown editors/engines, so we will recommand you NOT ommit protocols in any case for less compatibility issue.


text:
# Could someone please explain this 4-vector/tensor notation?

1. Mar 1, 2009

### AxiomOfChoice

If you can answer any of the questions below, your help will be greatly appreciated.

There's an equation from E&M (I believe the definition of the antisymmetric field tensor) that reads:

$$F_{\mu \nu} = \frac{\partial A_\nu}{\partial x^\mu} - \frac{\partial A_\mu}{\partial x^\nu},$$

where (of course) $A$ is the 4-vector potential. I have no idea how to parse this equation...what's going on with taking the partial of $A_\nu$ with respect to $x^\mu$? What's this notation describing, or telling me to do? I just don't see it.

Also (and this pertains to relativistic quantum mechanics), what's meant by something like

$$\partial_\mu [\partial_\nu \Psi(x^\mu)],$$

where (of course) $\Psi(x^\mu)$ is the wave function? I.e., what does it mean to operate on $\partial_\nu$ of something with $\partial_\mu$? Particularly when that something I'm operating on is a function of $x^\mu$? (By the way: In case the notation is unfamiliar to you, $\partial^\mu = \partial / \partial x_\mu$.) Does that turn into something? Can I compactify that? Or do I just have to leave it as $\partial_\mu [\partial_\nu \Psi(x^\mu)]$? Also, would I get an equivalent expression if I interchanged the order of $\partial_\mu$ and $\partial_\nu$; i.e., if I tried to evaluate $\partial_\nu [\partial_\mu \Psi(x^\mu)]$? Or would I get something quite different?

Does all of this boil down to "we need two distinct dummy indices, $\mu$ and $\nu$, to indicate that there shouldn't be any summation going on?"

(P.S. - I would like to thank David J. Griffiths for getting me into the habit of italicizing words I want to emphasize.)

2. Mar 1, 2009

### Peeter

Given two four vectors, one for the field, and one for the spacetime
position

$$\vec{A} = (A_0, -A_1, -A_2, -A_3)$$
$$\vec{x} = (x^0, x^1, x^2, x^3) = (ct, x, y, z)$$

This says that there's 16 scalar quantities that can be calculated by
taking derivatives. Two examples are:

$$F_{23} = \frac{\partial A_3}{\partial x^2} - \frac{\partial A_2}{\partial x^3} = \frac{\partial A_3}{\partial y} - \frac{\partial A_2}{\partial z}$$

$$F_{33} = \frac{\partial A_3}{\partial x^3} - \frac{\partial A_3}{\partial x^3} = 0$$

For your other question, I'd assume summation over $\mu$ is implied.

3. Mar 1, 2009

### AxiomOfChoice

Thanks a lot for your help!

What if I confront something like

$$\frac{\partial F^{\mu \nu}}{\partial x^\nu} = \partial_\nu F^{\mu \nu}?$$

Does that imply a sum over $\nu$?

4. Mar 1, 2009

### nicksauce

Yes, if an index is repeated as an upper index and a lower index, it implies a sum over that index.


text:
# Don't compare percentages

I wrote this for use.perl.org in 2006, but I keep looking for it at the beginning of each year as numeric illiterates try to do the same flawed analysis to prove something about programming languages in the last year (this year it’s Andrew Binstock at DDJ). I’m adding it to blogs.perl.org in case use.perl.org (now read only) suddenly disappears.

sigzero recently asked if the Perl community was atrophying, someone else pointed me to Tim O’Reilly’s State of the Computer Book Market, and there’s a Wikipedia revert war over Tiobe’s Programming Programming Index. All of these suffer from a misunderstanding of percentages and their value in making decisions and reaching conclusions. This is especially egregious when people divorce the percentages from the absolute numbers (either because the original data are restricted or the people know that they tell a different story).

I start with six topics I’ll call { A, B, C, D, E, F }, and I’ll arbitrarily assign them a number. It doesn’t matter what this number actually is. It could be hits on a web search engine, book sales on the topic, number of people moving to a town, or anything else. I’m just making all of this up to show that when people talk of trends in growth using percentages, they get the wrong answer because percentages remove information. The real answer involves some simple calculus (although without the fancy symbology) and a realization about what I should actually measure.

Let’s get to it then. I make up two sets of numbers. I’ll say one was from last month, and one was from this month. Since the universe is growing, the total results for this month are not the same as the that from last month. This is very important, because this is where percentages fail and how people use percentages incorrectly. Notice that in every case except one, the number for each topic increased. In the other case, the number stays the same.

I’ll change these numbers to percentages of the totals now. I round off to the nearest integer, but that won’t matter much. This is the first place where I’ll lose some information. With percentages, the difference in the totals between the two months disappear, but I’ll compare the percentages as if the totals were the same, and I’ll end up with the wrong answer.

First, notice in Table 1 that B had the greatest overall change (20,000), but actually dropped by 3% in Table 2, while A had a smaller change (17,000) in Table 1, but shot up 6% in Table 2. A has a relative percentages growth of 9%, although it’s growing more slowly. All topics except F had an increase in absolute numbers, but four actually dropped in percentages. Both C and E increased by a fifth of their absolute number, which is remarkable growth in a month, but their percentages dropped. That is, although they actually trend upward, the percentages trend in the opposite direction of their growth. B, which contributed the most absolute growth, dropped as much as F in percentages, although F had absolutely no growth. According to the relative numbers, B is losing in relative size as fast as F, although it added double the total number of F just in growth in one period.

I’ll do this for another month, adding the same absolute numbers as before to each topic. Each topic has the same absolute growth from month to month. Each is steadily increasing in absolute numbers except for F, which stays the same.

What happens to the percentages in steady state growth? I see the same relative downward trends in most cases, despite the fact that all but F are growing in actual size.

Now, in Table 4, the percentages are even worse for B. Again, the total increased by 48,000 hits, and again, B provided 20,000 new hits. But, by the percentages, B falls 1%. B is responsible for most of the growth, but also looks as if it is atrophying, while A is just getting up to the level where B started. Although all but one topic increased their absolute numbers, four fell in relative percentages.

Let’s go a year later than the last column, adding 12 times the same number of absolute growth to each result. Every topic continues a steady state growth.

What happens to the percentages a year later, shown as the last column in Table 6?

It’s the same decline. Although B has over six times the absolute numbers it did 15 months ago, it lost 7% in relative numbers. It’s still the largest and the fastest growing topic by absolute numbers, but the relative numbers make it look like the fastest declining topic.

The relative numbers are based on the total absolute number, and the problem comes in when I compare the percentages from month to month since the total absolute number changes. Percentages remove information to make things easier to see, but they aren’t there to be compared to percentages from another measurement. If the total number stays the same, the trend in percentages might have meaning, but if I don’t report the total size, the percentages don’t enough information for me to compare them across measurements.

If I used this analysis to figure out which books to publish, I’d miss the biggest and fastest growing market. If I used them to decide which city to do business in, I’d miss the one with the most customers and the one that’s adding the most customers. Analysts used to like to use this sort of thing to show why Apple Computer was a poor bet since it only had a minuscule percentage of the market, but that was clearly wrong. If I’d bought APPL 3 years ago at $11, I would have gained over 400% in value, compared to MSFT, selling at$26, losing 14% in the same time period. It’s because relative numbers aren’t the important ones.

So how do I do it then? I want to see how things are growing and what I should pay attention to. I could plot the absolute numbers, but a first-derivative plot makes it easier to see the real change. Like percentages, it removes the total number, but it leaves in the information about the direction and magnitude of the change. That’s the number I really want to compare. The first derivative is simply the change in the number over the time period. It’s a bit of calculus, although I won’t take it to an infinitesimal time slice.

Compare the utility of Table 7 to Table 6 for decision making. In Table 6, topics A and D look like they are the fastest growing, when in reality topic A grew more than either of them and continues to have a faster rate of change over the next year. The percentages have the least information, doing away with the absolute change and the absolute total size. If I’d bet my money on A because it looked as if it was growing fastest by percentages, at the end of the year I would have missed the top by 55,000, over a fifth of the absolute total for B.

Now, consider the business reason for looking at these sorts of numbers, and, for simplicity, imagine that the products for each topic have the same price. I don’t make more money by the higher rate of growth. Topic A doubled in its first month, but still sold less than Topic B. Betting on the fastest growing relative percentage (Topic A) in that case would have meant ignoring the greater number of sales I could get from Topic B. I make more money by making more sales, not more growth, and in this case, the worst-performer, percentage-wise, is the highest volume seller in every time period.

The first derivative plot shows that Topic B is the fastest growing market. I don’t care about the growth in terms of the size of the market, but the number of units I can sell. In business parlance, the percentage is the “market penetration”, but that’s not the interesting number to anyone other than those trying to drive someone out of a market (as in the case of the silly business between Microsoft and Apple arguments). Market penetration is the false idol of stock speculators. The totals and first-derivatives are the numbers that translate into real money and real value.


text:
# Why is Graph Isomorphism downward self reducible?

To say that graph isomorphism is downward self reducible means the following: There is an algorithm which decided graph isomorhpism for two given graphs of n vertices in polynomial time by accessing an oracle that solves graph isomorphism for (n-1) vertices.

To be clear, the oracle only tells 'Yes' or 'No'. It does not give us the isomorphism.

This problem appears as an exercise in Arora-Barak's chapter on Interactive Proofs.

How do I show that Graph Isomorphism is downward self-reducible?

My attempt is to start with an arbitrary vertex in $$G_1$$ and guess its image in $$G_2$$, and remove them and make an oracle call on the remaining graph. But now, I do not know how to proceed. These graphs being isomorphic may not necessarily mean that the original graphs are isomorphic.

• I removed your "NP-complete" tag, since graph isomorphism isn't known to be NP-complete (and seems not to be -- if it were, the polynomial hierarchy would collapse). Apr 24 '19 at 13:30
• @Apass.Jack clarfied Apr 25 '19 at 19:18
• Does the "Chapter on Interactive Proofs" imply probabilistic methods? Although I believe graph isomorphism is deterministic downward self polynomial-time reducible, can you clarify that the definition in the book is indeed having nothing to do randomization or probability? I do not have the book. May 7 '19 at 4:52

This answer shows how to prove an easier variation, the case of (undirected loopless) multigraph isomorphism.

### The problem of multigraph isomorphism is downward self-reducible

The simple idea is to merge two vertices in a way that distinguish those two vertices and edges involving them.

Let $$G$$ be a multigraph. If the sum of degrees of two vertices reaches the maximum, we will call an ordered pair of those two vertices a degree-maximum pair. For a degree-maximum pair $$(u,v)$$, construct $$G_{u,v}$$ as follows.

• Its vertices are all vertices of $$G$$ except $$u$$ and $$v$$, together with a new vertex $$u_v$$ which is understood as $$u$$ merged by $$v$$. Note that $$G_{u,v}$$ has one less vertice than $$G$$.

• Its edges consists of two parts.

• the edges of $$G$$ whose endpoints are neither $$u$$ nor $$v$$ with the same multiplicity. Let $$m$$ be the maximum multiplicity of these edges.
• for all vertex $$w$$ of $$G$$ that is neither $$u$$ nor $$v$$, edge $$\{w, u_v\}$$ with multiplicity that is the sum of the multiplicity of $$\{w,u\}$$ in $$G$$ and the product of $$m+1$$ and the multiplicity of $$\{w,v\}$$ in $$G$$.

It is easy to see that if we are given a multigraph $$G'$$ that is isomorphic to $$G_{u,v}$$ for some multigraph $$G$$, we can reconstruct $$G$$ from $$G'$$ up to isomorphism.

Suppose we are given two graphs of $$n$$ vertices, $$G$$ and $$H$$. Use the oracle to compare $$G_{u,v}$$ with $$H_{x,y}$$ for all tuples $$(u,v,x,y)$$, where $$(u,v)$$ is a degree-maximum pair in $$G$$ and $$(x,y)$$ is a degree-maximum pair in $$H$$. Once the oracle return yes, we conclude $$G$$ and $$H$$ are isomorphic; otherwise the oracle always return no, in which case we conclude $$G$$ and $$H$$ are not isomorphic. It take polynomial time to construct $$G_{u,v}$$ from $$G$$ or $$H_{x,y}$$ from $$H$$. There are less than $$n^2$$ tuples. So the whole algorithm takes polynomial time. QED.

I am yet to find a proof that shows the problem of (non-multi)graph isomorphism is downward self-reducible.

• As my effort to simplify is too aggressive, there is a minor/critical flaw in my algorithm above. I should have selected a degree-minimum connected pair $(u,v)$. Apr 26 '19 at 5:00


text:
# Homework Help: Integration - two sin functions

1. Aug 22, 2009

### exidez

1. The problem statement, all variables and given/known data

I have the answer I just dont know how he got it! I want to know how he got from the second line to the third line in the image below.

2. Relevant equations

3. The attempt at a solution

I have used integration by part and the u substitution method.

When substituting with u i am still left with the other terms in the other sine function.
When integrating by parts, it just doesn't simplify..

Is there another method i don't know about? There doesn't seem to be any trig identities either.

Last edited: Aug 22, 2009
2. Aug 22, 2009

### Дьявол

Hi & welcome to PF!

Use the product to sum formulae:

Regards.

3. Aug 22, 2009

### exidez

ok, that seems to be the way to go (i must remember these)
but i am still having problems evaluating it...

$$\frac{1}{2a^2}$$$$\int cos(at-2a\tau) d\tau - \int cos(at) d\tau$$

$$\frac{1}{2a^2}[\frac{sin(at-2a\tau)}{-2a}]$$from t to 0 $$- [cos(at)\tau]$$ from t to 0

im going to stop there because something is wrong already....

4. Aug 22, 2009

### Дьявол

Are a and t constants?

Obviously $\int cos(x)dx = sin(x)$.

Regards.

Last edited: Aug 23, 2009
5. Aug 22, 2009

### g_edgar

$$\sin(at-a\tau)\sin(a\tau) = ?$$

6. Aug 22, 2009

### exidez

$$sin(at-a\tau)sin(a\tau) = \frac{1}{2}(cos(at-a\tau-a\tau) - cos(at-a\tau+a\tau)) = \frac{1}{2}(cos(at-2a\tau) - cos(at))$$
subbing this into the integral and taking the half outside:

$$\frac{1}{2a^2}( \int cos(at-2a\tau) d\tau - \int cos(at) d\tau )$$

i treated cos(at) as a constant because we are integrating with respect to tau, not t....
or is this where i am going wrong?

Last edited: Aug 22, 2009
7. Aug 23, 2009

### Дьявол

Actually, you forgot the limits. So your integral would be:

$$\frac{1}{2a^2}( \int_{0}^{t} cos(at-2a\tau) d\tau - \int_{0}^{t} cos(at) d\tau)$$

Now make a substitution,

- for the first integral $w=at-2a\tau$

- for the second integral treat cos(at) as constant, so that:

$$\frac{1}{2a^2}( \int_{0}^{t} cos(at-2a\tau) d\tau - cos(at)\int_{0}^{t} d\tau)$$

Now find dw but do not forget the limits of the integral. You need to substitute 0, t for tau, in w.

Regards.

8. Aug 23, 2009

### exidez

Ok heres another attempt

$$\frac{1}{2a^2}( \int_{0}^{t} cos(at-2a\tau) d\tau - cos(at)\int_{0}^{t} d\tau)$$

let $$u = at-2a\tau$$
$$\frac{du}{d\tau} = -2a$$
$$\frac{du}{-2a} = d\tau$$

$$\frac{1}{2a^2}( \int_{0}^{t} cos(u) \frac{du}{-2a} - cos(at)\int_{0}^{t} d\tau)$$

$$\frac{1}{2a^2}(\frac{1}{-2a} \int_{0}^{t} cos(u) du - cos(at)\int_{0}^{t} d\tau)$$

$$\frac{1}{2a^2}(\frac{1}{-2a} \int_{0}^{t} cos(u) du - cos(at)(t-0))$$

$$\frac{1}{2a^2}(\frac{1}{-2a} \int_{0}^{t} cos(u) du - tcos(at))$$

substituting u back in and evaluating

$$\frac{1}{2a^2}(\frac{1}{-2a} (sin(at-2at) - sin(at)) - tcos(at))$$

$$\frac{1}{2a^2}(\frac{sin(at-2at)}{-2a} - \frac{sin(at)}{-2a} - tcos(at))$$

$$\frac{1}{2a^3}(\frac{sin(at-2at)}{-2} - \frac{sin(at)}{-2} - atcos(at))$$

$$-\frac{1}{4a^3}(sin(at-2at) - sin(at)} + 2atcos(at))$$

im stuck again, somehow i dont think that 4 is suppose to be in front there and the coefficient of 2 in front of the cos shouldn't be there either..... is there another trig identity i should know?

Last edited: Aug 23, 2009
9. Aug 23, 2009

### Дьявол

As I said, again you missed the limit.

$$\frac{1}{2a^2}( \int_{0}^{t} cos(at-2a\tau) d\tau - cos(at)\int_{0}^{t} d\tau)$$

let $$u = at-2a\tau$$
$$\frac{du}{d\tau} = -2a$$
$$\frac{du}{-2a} = d\tau$$

Now, for $\tau=0$, u=at and for $\tau=t$, u = at-2at=-at

So your integral should look like:

$$\frac{1}{2a^2}(\frac{1}{-2a} \int_{at}^{-at} cos(u) du - cos(at)\int_{0}^{t} d\tau)$$

Be careful with those limits!

Regards.

Last edited: Aug 23, 2009
10. Aug 23, 2009

### exidez

Oh, i now realize what you ment!
i always forget about those when i substitute u!
thanks will try again

11. Aug 23, 2009

### exidez

That help! Thankyou!! You dont know how long i have been trying to figure this out.

you posted the limits the wrong way round, but you probably mixed them up when you typed it into the brackets {}{}..

$$\frac{1}{2a^2}(\frac{1}{-2a} \int_{at}^{-at} cos(u) du - cos(at)\int_{0}^{t} d\tau)$$

$$\frac{1}{2a^2}(\frac{1}{-2a} \int_{at}^{-at} cos(u) du - cos(at)(t-0))$$

$$\frac{1}{2a^2}(\frac{1}{-2a} \int_{at}^{-at} cos(u) du - tcos(at))$$

$$\frac{1}{2a^2}(\frac{1}{-2a} (sin(-at) - sin(at)) - tcos(at))$$

$$\frac{1}{2a^2}(\frac{1}{-2a} (- sin(at) - sin(at)) - tcos(at))$$

$$\frac{1}{2a^2}(\frac{1}{a} (sin(at) - tcos(at))$$

$$\frac{1}{2a^3}(sin(at) - atcos(at)$$

Thanks again. I can now sleep knowing how he does it now! ;)

12. Aug 23, 2009

### Дьявол

Yep, you did it right.

Regards.


text:
# Can the compiler convert recursive algorithm into a dynamic programming

So I was going through the idea behind dynamic programming (memoization), and thought of this question.

Can a compiler convert any recursion into a table filling DP solution, of course given the hint(like some keyword or macro) from the programmer that the following recursive function can be solved with DP (so programmer knows that it exhibits overlapping sub-problems and optimal substructure)?

If it's possible why don't many of them have it, if there exists anyone that does?

• Python supports this using metaprogramming. It is questionable for a compiler to perform such an aggressive optimization, which is not necessarily advantageous in any given situation. – Yuval Filmus Oct 17 '18 at 4:04
• @YuvalFilmus I would like to see a document how Python achieve this. Why not advantageous, I didn't get the idea. If a compiler turns an excessive recursion into at least memoization is a great job. Into tabling greater job, no recursion overhead. – kelalaka Oct 17 '18 at 6:54
• Search for "@memoize" to see how Python handles this. – Yuval Filmus Oct 17 '18 at 7:43
• Whether a recursion is excessive or not could depend on parameters which the compiler can't possibly know. Memoization uses memory, so there is a non-trivial time-space tradeoff which you probably don't want the compiler to decide on. – Yuval Filmus Oct 17 '18 at 7:44
• @YuvalFilmus thank you that answers my question. I looked into this and apparently no compiler does this automatically. It's something a programmer can do, like define a macro/template. I guess the compilers have no such built-in macros. But I guess one can come up with a library. – anon Oct 17 '18 at 13:51

This kind of memoization can be enabled, for a specific procedure, using the decorator @memoize in Python, and perhaps similar metaprogramming mechanisms are available in other languages.


text:
Question

Find the mean then the mean absolute deviation (MAD) of the following data set Round your answer to two decimal places if necessary
3, 1, 5, 4, 8,6


text:
1
JEE Main 2022 (Online) 28th June Morning Shift
+4
-1

If the tangents drawn at the points $$O(0,0)$$ and $$P\left( {1 + \sqrt 5 ,2} \right)$$ on the circle $${x^2} + {y^2} - 2x - 4y = 0$$ intersect at the point Q, then the area of the triangle OPQ is equal to

A
$${{3 + \sqrt 5 } \over 2}$$
B
$${{4 + 2\sqrt 5 } \over 2}$$
C
$${{5 + 3\sqrt 5 } \over 2}$$
D
$${{7 + 3\sqrt 5 } \over 2}$$
2
JEE Main 2022 (Online) 27th June Evening Shift
+4
-1

The set of values of k, for which the circle $$C:4{x^2} + 4{y^2} - 12x + 8y + k = 0$$ lies inside the fourth quadrant and the point $$\left( {1, - {1 \over 3}} \right)$$ lies on or inside the circle C, is

A
an empty set
B
$$\left( {6,{{65} \over 9}} \right]$$
C
$$\left[ {{{80} \over 9},10} \right)$$
D
$$\left( {9,{{92} \over 9}} \right]$$
3
JEE Main 2022 (Online) 26th June Morning Shift
+4
-1

Let C be a circle passing through the points A(2, $$-$$1) and B(3, 4). The line segment AB s not a diameter of C. If r is the radius of C and its centre lies on the circle $${(x - 5)^2} + {(y - 1)^2} = {{13} \over 2}$$, then r2 is equal to:

A
32
B
$${{65} \over 2}$$
C
$${{61} \over 2}$$
D
30
4
JEE Main 2022 (Online) 25th June Evening Shift
+4
-1

A circle touches both the y-axis and the line x + y = 0. Then the locus of its center is :

A
$$y = \sqrt 2 x$$
B
$$x = \sqrt 2 y$$
C
$${y^2} - {x^2} = 2xy$$
D
$${x^2} - {y^2} = 2xy$$
JEE Main Subjects
Physics
Mechanics
Electricity
Optics
Modern Physics
Chemistry
Physical Chemistry
Inorganic Chemistry
Organic Chemistry
Mathematics
Algebra
Trigonometry
Coordinate Geometry
Calculus
EXAM MAP
Joint Entrance Examination


text:
Logic puzzles, riddles, math puzzles and brainteasers - pzzls.com

Vandaag is het 19 September 2018

# Self Ref - math puzzle

Difficulty:

Rating: 2.7/5.0

Find a number ABCDEFGHIJ such that A is the count of how many 0's are in the number, B is the number of 1's, and so on.

# Explanation

For other numbers of digits

n=1: no sequence possible n=2: no sequence possible n=3: no sequence possible n=4: 1210, 2020 n=5: 21200 n=6: no sequence possible n=7: 3211000 n=8: 42101000 n=9: 521001000 n=10: 6210001000 n>10: (n-4), 2, 1, 0 * (n-7), 1, 0, 0, 0

No 1, 2, or 3 digit numbers are possible. Letting x_i be the ith digit, starting with 0, we see that (1) x_0 + ... + x_n = n+1 and (2) 0*x_0 + ... + n*x_n = n+1, where n+1 is the number of digits.

I'll first prove that x_0 > n-3 if n>4. Assume not, then this implies that at least four of the x_i with i>0 are non-zero. But then we would have \sum_i i*x_i >= 10 by (2), impossible unless n=9, but it isn't possible in this case (51111100000 isn't valid).

Now I'll prove that x_0 < n-1. x_0 clearly can't equal n; assume x_0 = n-1 ==> x_{n-1} = 1 by (2) if n>3. Now only one of the remaining x_i may be non-zero, and we must have that x_0 + ... + x_n = n+1, but since x_0 + x_{n-1} = n ==> the remaining x_i = 1 ==> by (2) that x_2 = 1. But this can't be, since x_{n-1} = 1 ==> x_1>0. Now assuming x_0 = n-2 we conclude that x_{n-2} = 1 by (2) if n>5 ==> x_1 + ... + x_{n-3} + x_{n-1} + x_n = 2 and 1*x_1 + ... + (n-3)*x_{n-3} + (n-1)*x_{n-1} + n*x_n = 3 ==> x_1=1 and x_2=1, contradiction.

Case n>5:

We have that x_0 = n-3 and if n>=7 ==> x_{n-3}=1 ==> x_1=2 and x_2=1 by (1) and (2). For the case n=6 we see that x_{n-3}=2 leads to an easy contradiction, and we get the same result. The cases n=4,5 are easy enough to handle, and lead to the two solutions above.


text:
Revista de la Unión Matemática Argentina Home Editorial board For authors Latest issue In press MCA 2021 Online first Prize Search OJS

### Published volumes

##### 1936-1944
Threshold Ramsey multiplicity for odd cycles
Volume 64, no. 1 (2022), pp. 49–68

### Abstract

The Ramsey number $r(H)$ of a graph $H$ is the minimum $n$ such that any two-coloring of the edges of the complete graph $K_n$ contains a monochromatic copy of $H$. The threshold Ramsey multiplicity $m(H)$ is then the minimum number of monochromatic copies of $H$ taken over all two-edge-colorings of $K_{r(H)}$. The study of this concept was first proposed by Harary and Prins almost fifty years ago. In a companion paper, the authors have shown that there is a positive constant $c$ such that the threshold Ramsey multiplicity for a path or even cycle with $k$ vertices is at least $(ck)^k$, which is tight up to the value of $c$. Here, using different methods, we show that the same result also holds for odd cycles with $k$ vertices.


text:
# Generalized Auslander-Reiten Conjecture and Derived Equivalences

```@article{Pan2011GeneralizedAC,
title={Generalized Auslander-Reiten Conjecture and Derived Equivalences},
author={Shengyong Pan},
journal={Communications in Algebra},
year={2011},
volume={41},
pages={3695 - 3704}
}```
In this note, we prove that the generalized Auslander-Reiten conjecture is preserved under derived equivalences between Artin algebras.
5 Citations
Singular equivalences and Auslander-Reiten conjecture.
• Mathematics
• 2020
Auslander-Reiten conjecture, which says that an Artin algebra does not have any non-projective generator with vanishing self-extensions in all positive degrees, is shown to be invariant under certainExpand
Derived equivalences and Cohen-Macaulay Auslander algebras
• Mathematics
• 2015
Let A and B be Artin R-algebras of finite Cohen-Macaulay type. Then we prove that, if A and B are standard derived equivalent, then their Cohen-Macaulay Auslander algebras are also derivedExpand
Derived invariance by syzygy complexes
• Jiaqun Wei
• Mathematics
• Mathematical Proceedings of the Cambridge Philosophical Society
• 2017
Abstract We study derived invariance through syzygy complexes. In particular, we prove that syzygy-finite algebras and Igusa--Todorov algebras are invariant under derived equivalences. Consequently,Expand
Derived Equivalences for Φ-Cohen–Macaulay Auslander–Yoneda Algebras
In this paper, we introduce a class of algebras called Φ-Cohen–Macaulay Auslander–Yoneda algebras with Φ an admissible set of ℕ, and construct derived equivalences between these Φ-Cohen–MacaulayExpand
Stable functors of derived equivalences and Gorenstein projective modules
• Mathematics
• 2015
From certain triangle functors, called non-negative functors, between the bounded derived categories of abelian categories with enough projective objects, we introduce their stable functors which areExpand

#### References

SHOWING 1-10 OF 35 REFERENCES
Generalized Auslander-Reiten conjecture and tilting equivalences
We show that the generalized Auslander-Reiten conjecture is stable under tilting equivalences.
A Note on Auslander Bounds
Inspired by recent works on rings satisfying Auslander's conjecture, we study invariants, which we call Auslander bounds, and prove that they have strong relations to some homological conjectures.
Finiteness of finitistic dimension is invariant under derived equivalences
• Mathematics
• 2009
Abstract In this note, we show that the finiteness of the finitistic dimension of a left coherent ring is invariant under derived equivalences.
The Generalized Auslander–Reiten Condition for the bounded derived category
• Mathematics
• 2012
We consider the bounded derived category Db(R mod) of a left Noetherian ring R. We give a version of the Generalized Auslander–Reiten Condition for Db(R mod) that is equivalent to the classicalExpand
Derived equivalences for Cohen-Macaulay Auslander algebras
Let \$A\$ and \$B\$ be Gorenstein Artin algebras of Cohen-Macaulay finite type. We prove that, if \$A\$ and \$B\$ are derived equivalent, then their Cohen-Macaulay Auslander algebras are also derivedExpand
ON A CONJECTURE OF AUSLANDER AND REITEN
• Mathematics
• 2003
Abstract In studying Nakayama's 1958 conjecture on rings of infinite dominant dimension, Auslander and Reiten proposed the following generalization: Let Λ be an Artin algebra and M a Λ -generatorExpand
Tilting invariance of the Auslander-Reiten conjecture
Let \$R\$ be an artin algebra and \$T\$ be a tilting or cotilting \$R\$-module with \$S=\mr{End}_RT\$. We show that \$R\$ satisfies the Auslander-Reiten conjecture if and only if so does \$S\$.
Derived categories and syzygies
We introduce syzygies for derived categories and study their properties. Using these, we prove the derived invariance of the following classes of artin algebras: (1) syzygy-finite algebras, (2)Expand
Algebras that satisfy Auslander’s condition on vanishing of cohomology
• Mathematics
• 2008
Auslander conjectured that every Artin algebra satisfies a certain condition on vanishing of cohomology of finitely generated modules. The failure of this conjecture—by a 2003 counterexample due toExpand
Triangulated categories in the representation theory of finite dimensional algebras
Preface 1. Triangulated categories 2. Repetitive algebras 3. Tilting theory 4. Piecewise hereditary algebras 5. Trivial extension algebras References Index.