text:
Currently, our  browser tests are written in Ruby and RSpec, using Selenium to interact with our site through the browser. Awhile back, Selenium 2.0 was released, the primary new feature being integration with the WebDriver API. According to their documentation:

This addresses a number of limitations along with providing an alternative, and simpler, programming interface. The goal is to develop an object-oriented API that provides additional support for a larger number of browsers along with improved support for modern advanced web-app testing problems.

Although we’ve since upgraded the selenium server, our client-side testing code still uses the Selenium 1.x Client API. While this has been working for us, I wanted to spend my hackathon moving us to the newer WebDriver API to take advantage of its improvements. A great starting point has been Selenium’s migration documentation. I’m currently knee-deep in the migration process and below are some of the issues I’ve had to solve.

## WebDriverBackedSelenium

To ease the developer’s burden of migrating their entire codebase to use the new WebDriver API, the Selenium team has included a WebDriverBackedSelenium class which looks like the old Selenium 1.x object and internally adapts those 1.x commands to the 2.x WebDriver class’s commands. This means that you can pass this class to all your tests and all their calls will still work while you migrate your tests one-by-one. While this approach is great and what I want to do, it’s unfortunately only available in their Java client download and we are using the Ruby selenium-webdriver gem, which does not have this handy class.

The approach I’ve taken is to create a Ruby version of this class for the commands we use, except for specific cases where it makes sense to simply migrate the client code on the spot. Some of the translation is very straightforward, like migrating from the old API call of

selenium.open(url)

to the WebDriver API call of

webdriver.navigate.to(url)

However, some of the work is not as easy or does not have an exact mapping between the 2.x and 1.x API’s. In these cases, it has been helpful to look at how the Java WebDriverBackedSelenium client translates these commands. All of the command mappings can be found in the WebDriverCommandProcessor class.

## Element locators have changed

In Selenium 1.x, you could locate elements with a few different strategies: by id, name, identifier (id or name), link text, DOM, XPath, and CSS. You indicate which strategy you are using by prefixing your locator string with the strategy name (e.g. “id=element_id”). If you don’t specify the prefix, it guesses which one to use based on a few simple rules.

In the WebDriver API, the prefix and locator are separated out as separate arguments named ‘how’ and ‘what’ (e.g. {:id => “element_id”}). A simple translation layer has helped to allow me to migrate the client code one at a time, allowing for both syntaxes. One case that has proven difficult is when the prefix is not specified and the string could either be an id or a name (the “identifier” strategy). Unfortunately, we’ve done this with both id’s and names, which has made it difficult to know which one is correct without running the test and looking for a pass or fail.

## CSS3 selectors no longer use the sizzle library

In Selenium 1.x, the CSS selectors were handled via the Sizzle library, which implements a superset of the CSS3 spec. The WebDriver API, however, delegates CSS selecting to the browser’s native engine. Of course, we’re using some of the Sizzle features which are not part of the CSS3 spec. The primary offender has been searching for an element that contains a specific piece of text. Here’s an example of such a locator:

"css=div.simple-picker-menu div.simple-picker-menu-item:contains('#{value}')"

There’s not an equivalent CSS3 selector to find this element. The approach I’ve taken is to format the locator with an additional element to specify the text, which looks like this:

{:css => "div.simple-picker-menu div.simple-picker-menu-item", :text => value}

What this does, under the covers, is to use the first hash element to find all matching elements, not using the text. Then it selects the first matching element containing the given text.

But, what about crazier examples like this Selenium 1.x locator:

"css=.rally-dropdown-component:contains('Type') input.x4-form-field[value='#{type.name}']"

In this example, the check for text is in the middle of the selector, not at the end. These situations generally have 2 possible solutions:

1. Rewrite the locator using XPath instead of CSS, which allows for selecting elements based on their textual contents.
2. Break the locator in two. The first finds the element (or elements) with the matching text and the second finds the matching downstream element.

These are typically more difficult to implement as it is common for these strings to be used in different places from where they are defined. This makes the second option a bit more difficult to implement, without some refactoring.

## Filling out form fields

In Selenium 1.x, you can put text into an input field like so:

selenium.type(locator, value)

The WebDriver approach is to use a command like this:

webdriver.find_element(locator).send_keys(value)

However, there is a slight behavioral difference. The 1.x command will replace the existing text with the new value whereas the WebDriver command will simply have the browser type the given keys, adding to any existing text. In these situations, I’ve needed to call element.clear before element.send_keys.

## Interacting with elements that are not visible on the page

Related to the previous topic, Selenium 1.x lets you perform actions on elements that are not visible to the page. This means that I could call

selenium.type(locator, value)

which would populate, for instance, a hidden input field. Changing this code to use the new send_keys method won’t work because WebDriver will complain that it can’t interact with elements that are not visible. The solution I’ve taken for hidden input fields is to set them by executing JavaScript to set the element’s value attribute.

Some other instances of this issue that I’ve encountered are:

• Shared behaviors that click on a button that may or may not be visible and if it is not visible, it doesn’t matter. In 1.x, the click would still happen. I now need to add conditional logic to only click on the button if it is visible.
• We have some dropdown menus with links that only show up when the user hovers over a button. Our tests were written to simply click on the menu item link, which worked fine with Selenium 1.x. Now, we have to hover over the button first.

## Wrapping up

I still haven’t quite finished migrating all the tests yet (we have over 2,500 of them). One of the last big hurdles remaining is migrating the tests that drag and drop elements on the page. Like some of the issues above, it initially seemed trivial to migrate to the WebDriver drag and drop API, but the first attempts didn’t work properly.

Have you had to migrate from Selenium 1.x to 2.0? Is there any particular aspect that you found challenging?

I also wanted to investigate how we could run our test suite against multiple browsers. My goal is to run all of our tests against all of our supported browsers on every commit (or at least once per day). But, how can we run the tests against multiple browsers? The testing framework typically specifies which browser to test against? Have you solved this problem?

###### Send Us Your Feedback

Provide us with some information about yourself and we'll be in touch soon. * Required Field


text:
# Analyzing the Effects of Transactions Using T-Accounts Company, formed by Catherine Ekar, has...

Analyzing the Effects of Transactions Using T-Accounts  Company, formed by Catherine Ekar, has been operating for one year (2009). At the start of 2010,  T-account balances were as follows:

Required:

1. Using the data from these T-accounts, determine the amounts for the following on January 1, 2010:

2. Enter the following 2010 transactions in the T-accounts:

( a) Sold $1,500 of the investments for$1,500 cash.

( b) Sold one-fourth of the equipment for $1,000 in cash. ( c) Borrowed$2,600 from a local bank, signing a note due in three years (ignore interest).

( d) Paid \$300 cash on a short-term note payable (ignore interest).

3. Compute ending balances in the T-accounts to determine amounts for the following on December 31, 2010:

format: plain


text:
## Cryptology ePrint Archive: Report 2018/1176

Olivier Blazy and Paul Germouty and Duong Hieu Phan

Abstract: In Identity-based cryptography, in order to generalize one receiver encryption to multi-receiver encryption, wildcards were introduced: WIBE enables wildcard in receivers' pattern and Wicked-IBE allows one to generate a key for identities with wildcard. However, the use of wildcard makes the construction of WIBE, Wicked-IBE more complicated and significantly less efficient than the underlying IBE. The main reason is that the conventional identity's binary alphabet is extended to a ternary alphabet $\{0,1,*\}$ and the wildcard $*$ is always treated in a convoluted way in encryption or in key generation. In this paper, we show that when dealing with multi-receiver setting, wildcard is not necessary. We introduce a new downgradable property for IBE scheme and show that any IBE with this property, called DIBE, can be efficiently transformed into WIBE or Wicked-IBE.

While WIBE and Wicked-IBE have been used to construct Broadcast encryption, we go a step further by employing DIBE to construct Attribute-based Encryption of which the access policy is expressed as a boolean formula in the disjunctive normal form.

Category / Keywords: cryptographic protocols / Identity-Based Encryption, Attribute-Based Encryption

Original Publication (with minor differences): CT-RSA 2019


text:
Volume 396 - The 38th International Symposium on Lattice Field Theory (LATTICE2021) - Oral presentation
With complex Langevin towards the QCD phase diagram
B. Jaeger*, F. Attanasio and F.P.G. Ziegler
Full text: pdf
Pre-published on: May 16, 2022
Published on:
Abstract
We use complex Langevin simulations to explore the QCD phase diagram over a large range of chemical potentials and temperatures. For our simulations we use two flavours of dynamical Wilson fermions with a pion mass of approximately $480\,$MeV with a spatial volume of $24^3$. Here we report on consistency checks at zero chemical potentials and present our results for the fermion density and the Polyakov loop. We find that at the lowest temperature the fermion density remains zero until $m_N/3$, in line with the expectations from the Silver Blaze phenomenon.
DOI: https://doi.org/10.22323/1.396.0137
How to cite

Metadata are provided both in "article" format (very similar to INSPIRE) as this helps creating very compact bibliographies which can be beneficial to authors and readers, and in "proceeding" format which is more detailed and complete.

Open Access


text:
Seminar Calendar
for events the day of Tuesday, April 25, 2017.

.
events for the
events containing

Questions regarding events or the calendar should be directed to Tori Corkery.
      March 2017             April 2017              May 2017
Su Mo Tu We Th Fr Sa   Su Mo Tu We Th Fr Sa   Su Mo Tu We Th Fr Sa
1  2  3  4                      1       1  2  3  4  5  6
5  6  7  8  9 10 11    2  3  4  5  6  7  8    7  8  9 10 11 12 13
12 13 14 15 16 17 18    9 10 11 12 13 14 15   14 15 16 17 18 19 20
19 20 21 22 23 24 25   16 17 18 19 20 21 22   21 22 23 24 25 26 27
26 27 28 29 30 31      23 24 25 26 27 28 29   28 29 30 31
30

Tuesday, April 25, 2017

Topology Seminar
11:00 am   in 345 Altgeld Hall,  Tuesday, April 25, 2017
 Del Edit Copy
Submitted by rezk.
 Carmen Rovi (Indiana)To Be Announced

Geometry, Groups and Dynamics/GEAR Seminar
12:00 pm   in 243 Altgeld Hall,  Tuesday, April 25, 2017
 Del Edit Copy
Submitted by clein.
 Funda Gultepe (Illinois Math)To Be Announced

Logic Seminar
1:00 pm   in 345 Altgeld Hall,  Tuesday, April 25, 2017
 Del Edit Copy
Submitted by erikw.
 Nigel Pynn-Coates (UIUC)To Be Announced

Probability Seminar
2:00 pm   in 347 Altgeld Hall,  Tuesday, April 25, 2017
 Del Edit Copy
Submitted by wangjing.
 Yizao Wang (University of Cincinnati)A new family of random sup-measuresAbstract: Random sup-measures are natural objects when investigating extremes of stochastic processes. A new family of stationary and self-similar random sup-measures are introduced. The representation of this family of random sup-measures is based on intersections of independent stable regenerative sets. These random sup-measures arise in limit theorems for extremes of a family of stationary infinitely-divisible processes with long-range dependence. The talk will first review random sup-measures in extremal limit theorems, and then focus on the representation of the new family of random sup-measures. Joint work with Gennady Samorodnitsky.

Mathematics Colloquium: Tondeur Lectures in Mathematics
4:00 pm   in 245 Altgeld Hall,  Tuesday, April 25, 2017
 Del Edit Copy
Submitted by kapovich.
 Ulrike Tillmann (Oxford University)TBAAbstract: The Spring 2017 Tondeur Lectures in Mathematics will be held April 25-27, 2017. Faculty host: Vesna Stojanoska.


text:
# Operator algebra for momentum and magnetic vector potential

Let $\vec{A}$ be the magnetic vector potential and $\vec{p}$ be momentum.

$$\vec{p} \cdot \vec{A} \psi = (\vec{p} \cdot \vec{A}) \psi + \vec{A} \cdot (\vec{p} \psi)$$ $$\vec{A} \cdot \vec{p} \psi = (\vec{A} \cdot \vec{p}) \psi$$

This makes sense in coordinate representation, since $\vec{p}$ is differentiation which has a chain rule. $\vec{A}$ is dependent only on position, so it does not have a chain rule.

What if I decided to change my representation of the operators to momentum representation? Then $\vec{p}$ would not follow a chain rule, and instead I would find that the position dependent $\vec{A}$ would now have a chain rule (since it depends on derivatives of momentum).

This seems really weird to me, since the algebra of my operators (the chain rule in this example) now depends on my representation.

Perhaps this has always been the case and I just never realized it. Or it's due to messy notation. Does anyone know a truly representation independent way of expressing the above relations? I'm interested in this since I want to expand the Pauli equation into its standard form with a magnetic field (the Pauli equation actually contains cross products, but I'd like to stick with dot products here for simplicity).

• No, I think you already have the representation independent way. The equations you wrote at the top are representation independent -- they are the 'algebra' of the operators. You can derive them in either position or momentum space, and the steps in the derivation will look different, but you'll get the same result. – knzhou Dec 3 '15 at 22:28

The correct way is to consider $\vec A$ a function of the operator $\hat{\vec x}$. Then we have the ("abstract") operator $\hat{\vec p} \cdot \vec A(\hat{\vec x})$. (Operators with hats represent operators in the "abstract" Hilbert space).
Without concern for the messy details of the position and momentum operators (which technically do not have eigenfunctions, as their "eigenfunctions" are not in the Hilbert space), a function of an operator is defined as follows: $$f(\hat{A}) = \sum_\lambda f(\lambda) \left|\lambda\right>\left<\lambda\right|.$$ where $\hat{A}\left|\lambda \right> = \lambda\left|\lambda\right>$.
Now there remains no problem, you can simply represent the equations in position space: \begin{align*} \langle x \rvert \hat{\vec p} \cdot \vec A(\hat{\vec x}) \lvert \psi \rangle &= \int d^3x'\, \langle x \rvert \hat{\vec p} \lvert \vec x' \rangle \cdot \langle \vec x' \rvert \vec A(\hat{\vec x}) \lvert \psi \rangle \\ &= \int d^3x'\, \langle x \rvert \hat{\vec p} \lvert \vec x' \rangle \cdot \vec A(\vec x') \langle \vec x'\vert \psi \rangle \\ &= \int d^3x'\, \delta(\vec x - \vec x') (-i \hbar \nabla) \cdot \vec A(\vec x') \langle \vec x'\vert \psi \rangle \\ &= -i\hbar \nabla \vec A(\vec x) \psi(\vec x) = \vec p \cdot \vec A \psi(\vec x). \end{align*} Here we used, that the position representation of a state vector is given by $\psi(x) = \langle x \vert \psi \rangle$ and of an operator by $\langle x' \vert \hat O \vert x \rangle = \delta(x - x') O$ (all operators are local).
It also works without problem in momentum space: \begin{align*} \langle \vec p \rvert \hat{\vec p} \cdot \vec A(\hat{\vec x}) \lvert \psi \rangle &= \vec p \cdot \langle \vec p \rvert \vec A(\hat{\vec x}) \lvert \psi \rangle \\ &= \vec p \cdot \int d^3p'\, \langle \vec p \rvert \vec A(\hat{\vec x})\lvert \vec p' \rangle\langle \vec p'\rvert \psi \rangle. \end{align*} Here it is more difficult to evaluate the matrix element, one way to approach this is to use the above formula for functions of operators: \begin{align*} \langle \vec p \rvert \vec A(\hat{\vec x})\lvert \vec p' \rangle &= \int d^3x \, \langle \vec p \vert \vec x \rangle \vec A(x) \langle \vec x \vert \vec p' \rangle \\ &= \frac{1}{2\pi\hbar} \int d^3x\, e^{i \vec x \cdot (\vec p' - \vec p)} A(\vec x) \\ &= \frac{1}{2\pi\hbar} \tilde A(\vec p - \vec p'). \end{align*} So the matrix element is the Fourier transform of the potential at the argument $\vec p - \vec p'$. This gives the result for the above term: $$\langle \vec p \rvert \hat{\vec p} \cdot \vec A(\hat{\vec x}) \lvert \psi \rangle = \vec p \cdot \int \frac{d^3p'}{2\pi\hbar} \tilde{\vec A}(\vec p - \vec p') \psi(\vec p').$$ In other words: In momentum representation the term gets a non-local convolution integral. (One can also rewrite this equation to make $\vec A$ a function of the operator $\vec x$ in momentum representation, which is a derivative in $\vec p$, this is however even less useful for explicit calculation).


text:
## What Is an Envelope?

Envelopes are technical indicators that are typically plotted over a price chart with upper and lower bounds. The most common example of an envelope is a moving average envelope, which is created using two moving averages that define upper and lower price range levels. Envelopes are commonly used to help traders and investors identify extreme overbought and oversold conditions as well as trading ranges.

### Key Takeaways

• An envelope, in technical analysis, refers to trend lines plotted both above and below the current price.
• An envelope's upper and lower bands are typically generated by a simple moving average and a pre-determined distance above and below the moving average—but can be created using any number of other techniques.
• Many traders react to a sell signal when price reaches or crosses the upper band and a buy signal when price reaches or crosses the lower band of an envelope channel.

## How Envelopes Work

Traders can interpret envelopes in many different ways, but most use them to define trading ranges. When the price reaches the upper bound, the security is considered overbought, and a sell signal is generated. Conversely, when the price reaches the lower bound, the security is considered oversold, and a buy signal is generated. These strategies are based on mean reversion principles.

The upper and lower bounds are typically defined such that the price tends to stay within the upper and lower thresholds during normal conditions. For a volatile security, traders may use higher percentages when creating the envelope to avoid whipsaw trading signals. Meanwhile, less volatile securities may necessitate lower percentages to create a sufficient number of trading signals.

Envelopes are commonly used in conjunction with other forms of technical analysis to enhance the odds of success. For example, traders may identify potential opportunities when the price moves outside of the envelope and then look at chart patterns or volume metrics to identify when a tipping point is about to occur. After all, securities can trade at overbought or oversold conditions for a prolonged period of time.

## Example of an Envelope

Moving average envelopes are the most common type of envelope indicator. Using either a simple or exponential moving average, an envelope is created by defining a fixed percentage to create upper and lower bounds.

Let's take a look at a five percent simple moving average envelope for the S&P 500 SPDR (SPY):

The calculations for this envelope are:

\begin{aligned} &\text{Upper Bound} = \text{SMA}_{50} + \text{SMA}_{50}*0.05\\ &\text{Lower Bound} = \text{SMA}_{50} - \text{SMA}_{50}*0.05\\ &\text{Midpoint} = \text{SMA}_{50}\\ \\ \textbf{where:}&\\ &\text{SMA}_{50}=\text{50-day Simple Moving Average} \\ \end{aligned}

Traders may have taken a short position in the exchange-traded fund when the price moved beyond the upper range and a long position when the price moved below the lower range. In these cases, the trader would have benefited from the reversion to the mean over the following periods. Traders may set stop-loss points at a fixed percentage beyond the upper and lower bounds, while take-profit points are often set at the midpoint line.

For more, see: Moving Average Envelopes: A Popular Trading Tool


text:
### Home

The files presented here replicate the analysis of "Further Evidence for Discrete-State Mediation in Recognition Memory" by Kellen, Singmann, Vogt, & Klauer (2015). The following files are present: 1. analysis-script.R: This commented .R file performs the analyses reported in the manuscript and produces all the numbers given in the text, Table 1, and Figures 4 and 6 (this is the main file). It requires the files listed below as numbers 2 to 8 (or the zip file). 2. words-data.txt: Provides the data of the word session. 3. pics-data.txt: Provides the data of the picture session. 4. words.sdt.model: MPTinR model file containing the UVSD model for the word session. 5. pics.sdt.model: MPTinR model file containing the UVSD model for the picture session. 6. mpt-models.R: .R file containing the likelihood functions for the 2HT models for word and picture session. 7. mm.words.rda: Binary R data file providing the $G^2$ values obtained in the mimicry analysis of the word session. 8. mm.pics.rda: Binary R data file providing the $G^2$ values obtained in the mimicry analysis of the picture session. 9. words.mimicry.R commented R script that performs the (lengthy) model mimicry analysis for the word condition. 10. pics.mimicry.R: same as before, but for the picture condition and not commented. 11. modeling_details.pdf: Detailed description of the 2HTM's state-response mapping function as well as details on the linear mixed modeling of the RTs. 12. kellen_singmann_vogt_kaluer_2015.zip: zip file containing all of the files above. In case of questions contact [David Kellen][1] or [Henrik Singmann][2]. Freiburg, May 2014 Full reference: Kellen, D., Singmann, H., Vogt, J., & Christoph Klauer, K. (2015). Further Evidence for Discrete-State Mediation in Recognition Memory. *Experimental Psychology*, 62(1), 40–53. [http://doi.org/10.1027/1618-3169/a000272][3] [1]: http://davidkellen.org/ [2]: http://singmann.org/ [3]: http://doi.org/10.1027/1618-3169/a000272


text:
## Algebra: A Combined Approach (4th Edition)

$x=-1$ $y=3$
First, times the first function by 2. And you get $10X+2Y=-4$, then you add two function together. You get $14X=-14$. $x=-1$ then you plug $x=-1$ into one of function. $Y=3$


text:
# Why Excel is better than Python

Mar 6, 2022

Actuaries, quants and other mathmatical finance experts use Excel a lot. They know it’s not a good practice to use Excel for complex modeling, but they keep using it anyway.

Excel is bad because it’s error prone. Numbers are manually input in small cells in large sheets. Formulas have nested parentheses and refer to other cells by addresses, which makes it hard to understand them. Workbooks are hard to compare each other and not ideal for version-control.

Despite all of that, actuaries stick to Excel. Some try to introduce Python, or whatever programming language they like, aiming to replace Excel with it. However, in most cases, such initiatives fail, because the users are so much in love with Excel, and without exploring much, they think Python is not a good fit for their jobs.

Excel’s popularity is often attributed to it’s prevalence and ease of learning. But we want to think deeper here, because the reason why modelx was born is to bring Excel’s advantages into Python. What is it that makes people feel comfortable using Excel over Python?

## Python runs, Excel stays

A Python program runs. It runs from the top of the script file through the end of it. Before it runs, it’s just a text file. The program exists for just a short period of time while it’s running, and when it finishes, it vanishes and goes back to a text file again.

In contrast, Excel doesn’t run. it doesn’t even have a “Run” button. It persists. it’s static, in a way that it always holds the results of your formulas.

Which gives you peace of mind more, a thing that has to be running to exist and to get your request done, or a thing that stays still and always holds the results for you?

## Loop or recursion

How do you calculate present value of cashflows in Python? You would do something like:

pv = 0
for i in range(10):
pv += cashflow[i] / (1 + 0.5)**(i + 1)

Or if you’re more Pythonic, then your code would be more like:

pv = sum(cashflow[i] / (1 + 0.5)**(i + 1) for i in range(10))

Either way, the same logic is looped and intermediate values, such as pv at i=5 or cashflow[i] / (1 + 0.5)**(i + 1), are not remembered at the end of the loop.

Now, let’s see how you would do it in Excel:

As you see on the left, Excel uses recursion instead of loop, to repeat the same formula, so pv for all the i are available. On the right are a different way of taking the present value. In this case, cashflow[i] / (1 + 0.5)**(i + 1) for all the i are preserved. Excel remembers and presents the intermediate values used for obtaining the end result. Excel lets you inspect intermediate values and trace formula dependencies, which allows you to feel more comfortable with the result’s accuracy.

## Formula-value coupling

In Excel, a formula and its value are in the same cell. They are always coupled. As long as Excel is in the automatic calculation mode, you are certain that the value is always up to date and any updates on the formula are reflected.

In Python, a piece of code and its result are separated. In the case of the example above, the result is stored in the variable pv. pv and it’s code, for example, sum(cashflow[i] / (1 + 0.5)**(i + 1) for i in range(10)), exist separately. And even if the code is updated, pv holds the old value. You need to explicitly update pv, for example, by rerunning the entire script.

## Single entry exit

A python program has a single entry point and single exit point. Python interprets a script file from the top of the file through the bottom. Usually, a part of the entire program does not run individually without it’s context.

On the other hand, an Excel file has no explicit entry point and exit point, because it does not “run”. So you don’t need to care about the order of calculations. You don’t need to be think about which formula should be evaluated before which. Excel resolves the order for you. If the order is invalid, Excel detects the cyclic reference.

## Object-oriented

Excel is object-oriented out of the box. You don’t even notice that you’re building a model in an objected-oriented way. You don’t need to define classes and methods on your own, because objects, such as workbooks, worksheets and ranges are already provided by Excel for you to start defining formulas. This lets you break down the entire logic into small pieces of formulas. Without even noticing, you follow the best practice of splitting large logic into components.

In Python, you would be likely to end up writing hundreds of lines of code in one script file without defining any classes or functions. It’s hard to start from defining class and functions from scratch on a plain text file without proper experience. Even if you’re capable of doing, the chances are, your colleagues in your team are not.

## modelx design

modelx was invented to address those issues. Models in modelx work like Excel workbooks. A modelx model does not run. It stays. It keeps all the intermediate values so you can trace the formulas and values. Formulas and their values are coupled. Models don’t have specific entry points or end points. Models are object-oriented. You don’t need to write class or methods. This is why modelx’s catchphrase is “Use Python like a spreadsheet!”.


text:
# Interpreting coefficients after transforming Y (dependent) variable

I have been working on linear regression for forecasting purposes.

I have a model where I have used a BoxCox transformation on the $$Y$$ variable (Sales) with $$\lambda = 0.3$$. The model is as follows:

$$Y = 13 - 0.2 X_1 + 3 X_2$$

How can I interpret the effect of sales from each variable, given the transformation?

For instance, assume $$X_1=5$$ and $$X_2=0.3$$ then we get:

$$Y = 13 - 0.2 \times 5 + 3 \times 0.3 = 12.9$$

Reverse BoxCox of 12.9 with $$\lambda = 0.3$$ is 196. So it forecasts 196 sales. But if we increase $$X_2$$ from 0.3 to 1 and increase $$X_1$$ from 5 to 10 then we get:

$$Y = 13 - 0.2 \times 10 + 3 \times 1 = 14$$

Reverse BoxCox then gives 244 sales forecasted sales. An increase of 48 sales. But how much of that is down to $$X_1$$ and $$X_2$$?

EDIT: to make the above point clear:

If $$X_1$$ went from 5 to 10 but $$X_2$$ doesn't change:

$$Y = 13 - 0.2 \times 10 + 3 \times 0.3 = 11.9$$, transform to 159 sales. A -37 decrease from the starting position (196-159)

However, if $$X_2$$ went from 0.3 to 1 but $$X_1$$ doesn't change: $$Y = 13 - 0.2 \times 5 + 3 \times 1 = 15$$, transforms to 294 sales. A +98 increase in sales (294-196).

But if $$X_2$$ increases sales by 98 and $$X_1$$ decreases sales by 37 you would expect the net increase to be +61 when you include both changes. But from earlier we found that by applying both we actually get a +48 increase in sales!

How can we work out the actual sales change resulting in changes in $$X_1$$ and $$X_2$$?


text:
# Improving the localisation accuracy of AUVs operating in highly variable environmental conditions

Randeni Pathiranachchilage, SAT ORCID: 0000-0003-3266-2810 2018 , 'Improving the localisation accuracy of AUVs operating in highly variable environmental conditions', PhD thesis, University of Tasmania.

 Preview
PDF (Whole thesis (published material removed))

| Preview
PDF (Whole thesis)
Full text restricted

## Abstract

The objective of this thesis is to contribute to Autonomous Underwater Vehicle (AUV) navigation by improving vehicle localisation accuracy when Doppler Velocity Log (DVL) bottom-tracking is unavailable. The Inertial Navigation System (INS) based localisation solution is prone to extreme uncertainties due to double integration of inherent errors within the INS acceleration measurements, unless the solution being externally aided (e.g. velocity measurements using the DVL bottom-track). As a solution for this, an improved model-aided INS localisation technique is introduced, which is complimented with the development of a novel model calibration and new water column velocity estimation method. The techniques established in this project are tested and validated using experimental data from a set of field manoeuvres using a Gavia class AUV and the performance is compared against other commonly used localisation methods.
A baseline mathematical model was developed in this work using system identification to predict the motion response of the AUV based on its control commands. However, such models are generally calibrated for low water column velocities and a standard vehicle configuration, and are limited in application for variations in environmental conditions. To address this limitation, a novel model calibration technique was established to field calibrate the parameters within the baseline model to the current operating condition and vehicle configuration. Model calibration improved the results of the baseline model up to 73% when operating in low energy environments and the AUV position can be computed within an uncertainty range of 1.5% of the distance travelled. In comparison, uncertainties of conventional non-bottom-tracking localisation techniques could be up to 10% in similar environmental conditions. A secondary approach is also presented to determine the hydrodynamic coefficients of the mathematical model using Computational Fluid Dynamics (CFD) simulations and captive model experiments when the AUV is operating in complex flow conditions.
A non-acoustic method was introduced to estimate the velocity of the water column using the motion response of the AUV. This method is capable of accurately estimating water column velocities in proximity to the AUV (i.e., the water column velocities at the same depth as the vehicle is), which is not typically resolved with existing methods such as acoustic Doppler current profilers. When the mathematical model-aided localisation solution is complimented with water column velocity prediction method, the localisation error is limited to less than 6% of the distance travelled even in extremely high currents (i.e. >2 m s$$^{-1}$$ in tested conditions). In such environmental conditions, the uncertainties of other commonly used non-bottom-tracking localisation methods, as tested against in this work, such as DVL water-track mode and unaided INS could be above 30%.
One of the key advantages of the proposed localisation technique is that it could be applied to any torpedo shaped AUV (for example, platforms such as REMUS, Iver, Bluefin, Explorer, etc.) of any configuration by simply conducting a set of established field manoeuvres to identify its mathematical model parameters. Further, additional sensors beyond a typical AUV navigational payload (i.e. global positioning, accelerometers and gyroscopes) are not required to implement this technique in an AUV. The localisation technique developed in this thesis is capable of improving the motion control and navigation solution of the AUV in the absence of DVL bottom-tracking, which is critical for the expansion of vehicle performance in extreme environmental conditions.


text:
Choosing a free learning management system (LMS) can be challenging. What works for one organization isn’t always ideal for another, and the subtle differences between two seemingly similar LMSs can directly affect the success of your e-learning program. The first step in making an informed decision is to compare features and research your options. Here’s a review on a relatively new contender in the world of e-learning: Romy LMS.

### Romy LMS Offers a Simpler LMS Solution

While it may be tempting to go with the free learning management system that offers the most features, that’s generally not a wise strategy. Unless your company or academic institution really needs an in-depth LMS for a very specific purpose, a general rule of thumb is that too much clutter is a hindrance to both the course creation and the learning process. Romy LMS impressed us by providing essential features while eliminating unnecessary fluff.

### Sleek and Slim without Sacrificing Vital Features

The Romy LMS training platform is remarkably user-friendly. In fact, it’s so easy to use that even technologically challenged users should have no problem figuring it out quickly. Highly intuitive and direct, the Romy LMS platform actually feels familiar. This is a major achievement, as plenty of other LMSs practically require a computer technology just to navigate mazes of menus and walls of text. In short, Romy LMS is highly accessible – and that’s a huge advantage in most applications. Sometimes less is more.

### What to Expect?

Just because Romy LMS keeps it simple doesn’t mean you’re going to want for features. We get the impression that “quality over quantity” is a mantra over at the Romy LMS development headquarters. Each feature does exactly what it needs to do, giving both administrators and learners everything needed and more. The Romy LMS free learning management system covers all of the bases required of a successful e-learning program, and then some. Here are some of the major features this gentle giant offers:

• A Comfortable and Highly Functional Interface
From the moment you open Romy LMS, you immediately know what you’re doing. The tables and menus are organized in a way that facilitates fluid, unimpeded navigation. Administrators can instinctively create and manage content with just a few clicks, and learners can enjoy a distraction-free training platform that makes sure that the content stands at the forefront. No frustration, and no time wasted.
• Versatility without Compromising Focus
Meeting a wide range of demands is never easy for software developers, but Romy LMS has done a remarkable job creating an LMS that can be used equally successfully by a small startup company or a major academic institution.

While we’re assuming small to medium-sized businesses would likely appreciate Romy LMS’ approach most, this highly scalable free learning management system does offer plenty of room to grow. This is a major achievement, as many other LMSs target specific markets such as schools, small businesses, or large corporations. Romy LMS seems equipped to handle whatever you throw at it.

• Responsive Across All Devices
E-learning is possible for a variety of mobile devices in addition to desktop computers and laptops. Romy LMS makes it possible for administrators and learners to access the training platform via Apple and Android platforms.
• Multimedia Capable
Today’s online courses depend on images, videos, PDFs, PowerPoint, Flash, and many other media formats. Romy LMS can handle them all.
• A Quick and Simple Automatic Grading System
Romy LMS’ approach to grading is an A+ in our book. The automated grading saves trainers and teachers a substantial amount of time, and the system notifies administrators when written answers need grading. This ensures that there is still a human touch when necessary, without forcing admins to spend hours grading.
• Course Summaries and Feedback
Course summaries let administrators monitor and track the progress of each individual student. Learner feedback options make e-learning a two-way street, giving learners the opportunity to express what they like and dislike about the course.
• Rewards, Incentives, and Certification
Some friendly competition can be a powerful motivational tool. The Romy LMS free learning management system gives teachers options such as gamification, badges, awards, and leaderboards to encourage learners to reach their full potential. At the end of the course, Romy LMS facilitates proper accreditation.

### Summary

Though relatively new to the game, Romy LMS is a huge winner if your organization requires a comprehensive, intuitive training platform. The user-friendly interface, robust feature list, and excellent scalability all just make sense. We had quite a few “why didn’t we think of that” moments while navigating the interface, and using it felt so natural right from the start. If your organization needs a deceptively powerful LMS without the filler, this is the one. Don’t take our word for it though; try the free demo for yourself.

Feel free to ask questions, send feedback and even point out mistakes. Great conversations start with just a single word. How to write better comments?
##### 1 comment
1. Gdweblab is one of the best SEO and web development company . Give us a call or email us at [email redacted] for a boost in your online visibility.

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

## Meet the Math Blogger : Josh Young from Mathematical Mischief

Every mathematics student is in his own a special case — having his own qualities and snags. A math blogger is even more special.  He is more than just a mathematician or just a blogger. A math blogger is an entertainer… a magician, who devises techniques of making math more readable and even more interesting. There are hundreds of such…

## Best Mass Communication Colleges in India

Mass Media or Mass communication is a tool for transfer of information and ideas to the masses. Indian media is about two centuries old. Started with print, it has ultimately evolved and involved into new dimensions. From newspaper journalism to TV anchoring, media were and will always be, very important to democratic India. This one reason is enough to explain…

## Examination Strategies : Tactics & Tips

Every student or graduate knows how hard the first experience of passing exams is. Preliminary preparation starves the nervous system and the physical condition of the human body, however, the exam itself is always a stressful situation, which requires a candidate a great manifestation of mental and physical abilities. Therefore, just the knowledge of a subject is not enough for…

## E-Learning Strategies To Make Students More Engaged With The Lesson

The efficacy of teaching doesn’t just lie on whether you use traditional or modern tools. Sometimes, the best way to make sure lessons reach across the audience is to have proper strategy. Time and again, there has always been one reason why people fail to learn a particular subject or topic. This has always been the lack of interest or…

## Apply to MBA Colleges as Per CAT Scores

The higher education system has led to a massive demand of qualified and skilled employees in renowned corporate companies as well as start-ups. One of the most sought after and valued post graduate degree of all time is MBA - Masters in Business Administration.

## How eLearning is improving the current education system?

The role of teachers are changing in the current scenario. Earlier education system was straightforward. Go to college, study and get out. Clearing doubts and understanding concepts from teachers were really simple as they were more accessible and dedicated. Teachers hardly took teaching as job, rather they always imparted it as social responsibility to make the world a better place.…


text:
# Properties

 Label 5400.2.a.w Level $5400$ Weight $2$ Character orbit 5400.a Self dual yes Analytic conductor $43.119$ Analytic rank $1$ Dimension $1$ CM no Inner twists $1$

# Related objects

## Newspace parameters

 Level: $$N$$ $$=$$ $$5400 = 2^{3} \cdot 3^{3} \cdot 5^{2}$$ Weight: $$k$$ $$=$$ $$2$$ Character orbit: $$[\chi]$$ $$=$$ 5400.a (trivial)

## Newform invariants

 Self dual: yes Analytic conductor: $$43.1192170915$$ Analytic rank: $$1$$ Dimension: $$1$$ Coefficient field: $$\mathbb{Q}$$ Coefficient ring: $$\mathbb{Z}$$ Coefficient ring index: $$1$$ Twist minimal: no (minimal twist has level 1080) Fricke sign: $$1$$ Sato-Tate group: $\mathrm{SU}(2)$

## $q$-expansion

 $$f(q)$$ $$=$$ $$q+O(q^{10})$$ q $$q - 2 q^{11} + 3 q^{17} - q^{19} + 3 q^{23} - 4 q^{29} - 5 q^{31} - 10 q^{37} - 6 q^{41} + 6 q^{43} + 8 q^{47} - 7 q^{49} + 3 q^{53} + 5 q^{61} + 2 q^{67} - 2 q^{71} - 6 q^{73} - 11 q^{79} + 9 q^{83} - 10 q^{89} - 8 q^{97}+O(q^{100})$$ q - 2 * q^11 + 3 * q^17 - q^19 + 3 * q^23 - 4 * q^29 - 5 * q^31 - 10 * q^37 - 6 * q^41 + 6 * q^43 + 8 * q^47 - 7 * q^49 + 3 * q^53 + 5 * q^61 + 2 * q^67 - 2 * q^71 - 6 * q^73 - 11 * q^79 + 9 * q^83 - 10 * q^89 - 8 * q^97

## Embeddings

For each embedding $$\iota_m$$ of the coefficient field, the values $$\iota_m(a_n)$$ are shown below.

For more information on an embedded modular form you can click on its label.

Label $$\iota_m(\nu)$$ $$a_{2}$$ $$a_{3}$$ $$a_{4}$$ $$a_{5}$$ $$a_{6}$$ $$a_{7}$$ $$a_{8}$$ $$a_{9}$$ $$a_{10}$$
1.1
 0
0 0 0 0 0 0 0 0 0
 $$n$$: e.g. 2-40 or 990-1000 Significant digits: Format: Complex embeddings Normalized embeddings Satake parameters Satake angles

## Atkin-Lehner signs

$$p$$ Sign
$$2$$ $$-1$$
$$3$$ $$-1$$
$$5$$ $$1$$

## Inner twists

This newform does not admit any (nontrivial) inner twists.

## Twists

By twisting character orbit
Char Parity Ord Mult Type Twist Min Dim
1.a even 1 1 trivial 5400.2.a.w 1
3.b odd 2 1 5400.2.a.x 1
5.b even 2 1 1080.2.a.d 1
5.c odd 4 2 5400.2.f.j 2
15.d odd 2 1 1080.2.a.j yes 1
15.e even 4 2 5400.2.f.r 2
20.d odd 2 1 2160.2.a.f 1
40.e odd 2 1 8640.2.a.bs 1
40.f even 2 1 8640.2.a.bt 1
45.h odd 6 2 3240.2.q.e 2
45.j even 6 2 3240.2.q.s 2
60.h even 2 1 2160.2.a.r 1
120.i odd 2 1 8640.2.a.o 1
120.m even 2 1 8640.2.a.p 1

By twisted newform orbit
Twist Min Dim Char Parity Ord Mult Type
1080.2.a.d 1 5.b even 2 1
1080.2.a.j yes 1 15.d odd 2 1
2160.2.a.f 1 20.d odd 2 1
2160.2.a.r 1 60.h even 2 1
3240.2.q.e 2 45.h odd 6 2
3240.2.q.s 2 45.j even 6 2
5400.2.a.w 1 1.a even 1 1 trivial
5400.2.a.x 1 3.b odd 2 1
5400.2.f.j 2 5.c odd 4 2
5400.2.f.r 2 15.e even 4 2
8640.2.a.o 1 120.i odd 2 1
8640.2.a.p 1 120.m even 2 1
8640.2.a.bs 1 40.e odd 2 1
8640.2.a.bt 1 40.f even 2 1

## Hecke kernels

This newform subspace can be constructed as the intersection of the kernels of the following linear operators acting on $$S_{2}^{\mathrm{new}}(\Gamma_0(5400))$$:

 $$T_{7}$$ T7 $$T_{11} + 2$$ T11 + 2 $$T_{13}$$ T13 $$T_{17} - 3$$ T17 - 3

## Hecke characteristic polynomials

$p$ $F_p(T)$
$2$ $$T$$
$3$ $$T$$
$5$ $$T$$
$7$ $$T$$
$11$ $$T + 2$$
$13$ $$T$$
$17$ $$T - 3$$
$19$ $$T + 1$$
$23$ $$T - 3$$
$29$ $$T + 4$$
$31$ $$T + 5$$
$37$ $$T + 10$$
$41$ $$T + 6$$
$43$ $$T - 6$$
$47$ $$T - 8$$
$53$ $$T - 3$$
$59$ $$T$$
$61$ $$T - 5$$
$67$ $$T - 2$$
$71$ $$T + 2$$
$73$ $$T + 6$$
$79$ $$T + 11$$
$83$ $$T - 9$$
$89$ $$T + 10$$
$97$ $$T + 8$$


text:
# Find all the limit points and interior points (basic topology)

## Homework Statement

Find all the limit points and interior points of following sets in R2
A={(x,y): 0<=x<=1, 0<=y<=1} *here I used "<=" symbol to name as "less then or equal".
B={1-1/n: n=1,2,3,...}

## The Attempt at a Solution

the limit point of B is 1 as n goes to infinity. because for the limit point, in the neighborhood there must be infinitely many points.
and I think the limit points of A must be all (x,y) values, because in the neighborhood ve can find infinitely many points in the neighborhood of all points.
my problem is with interior points.
How can I approach in order to find interior points? and what are the interior points of these sets???

Related Calculus and Beyond Homework Help News on Phys.org
HallsofIvy
Homework Helper
An interior point of a set A is a point, p, such that some neighborhood of p is contained in A. Look at, for example, points like (0, 1/2), or (1, 3/4), or (2/3, 1), etc. which lie on the lines bounding the rectangle. Any neighborhood must have some points on every side of the point and so some on the outside of the rectangle. Those cannot be interior points.

For the second case, you might want to actually write down some of the points:
0, 1/2, 2/3, 3/4, etc. Suppose you drew an interval, say, (1/4, 3/8) around 1/2 or (2/3- 1/24, 2/3+ 1/24) about 2/3? (1/24 is half of 1/12, the distance from 2/3 to 3/4.)

An interior point of a set A is a point, p, such that some neighborhood of p is contained in A. Look at, for example, points like (0, 1/2), or (1, 3/4), or (2/3, 1), etc. which lie on the lines bounding the rectangle. Any neighborhood must have some points on every side of the point and so some on the outside of the rectangle. Those cannot be interior points.

For the second case, you might want to actually write down some of the points:
0, 1/2, 2/3, 3/4, etc. Suppose you drew an interval, say, (1/4, 3/8) around 1/2 or (2/3- 1/24, 2/3+ 1/24) about 2/3? (1/24 is half of 1/12, the distance from 2/3 to 3/4.)
So, you mean (for B={1-1/n}) that for some points p, I cannot find a neighborhood which is a subset of B. for example in [1/4, 3/8] we cannot find any neighborhood which belongs to B. so, in B there is no interior points. Is that true?


text:
Calculating the amplitude that a particle is spin up

The wavefunction for a spin 1/2 particle is a spinor field of the form $$\psi(\mathbf{x},t)=\left( \begin{array}{cc} \psi_{+}(\mathbf{x},t)\\ \psi_{-}(\mathbf{x},t) \end{array} \right).$$
$\psi_{+}(\mathbf{x},t)$ is the amplitude that the particle is both spin up and located at position x at time t. How can I calculate the amplitude that the particle is just spin up, without any regards for its position? Would it be something like
$$\int \psi_{+}(\mathbf{x,t})d^3 \mathbf{x}?$$

Last edited:

The wavefunction for a spin 1/2 particle is a spinor field of the form $$\psi(\mathbf{x},t)=\left( \begin{array}{cc} \psi_{+}(\mathbf{x},t)\\ \psi_{-}(\mathbf{x},t) \end{array} \right).$$
$\psi_{+}(\mathbf{x},t)$ is the amplitude that the particle is both spin up and located at position x at time t. How can I calculate the amplitude that the particle is just spin up, without any regards for its position? Would it be something like
$$\int \psi_{+}(\mathbf{x,t})d^3 \mathbf{x}?$$

Here is what I thought of

$$|\Psi\rangle = |\psi\rangle\otimes|\alpha\rangle$$

$$\int dx |x\rangle\langle x| \otimes \left(|\uparrow\rangle\langle \uparrow |+ |\downarrow\rangle\langle \downarrow |\right) = \mathbb{I}$$

Thus we have the expansion
$$\left[\int dx |x\rangle\langle x| \otimes \left(|\uparrow\rangle\langle \uparrow |+ |\downarrow\rangle\langle \downarrow |\right)\right] |\Psi\rangle = \int dx \langle x|\psi\rangle |x\rangle \otimes \left(\langle \uparrow |\alpha\rangle |\uparrow\rangle + \langle \downarrow |\alpha\rangle |\downarrow\rangle\right)$$

Take the inner product with spin up state vector. [I dont know if this is valid]
$$\langle \uparrow |\Psi\rangle = \int dx \langle x|\psi\rangle \langle \uparrow |\alpha\rangle |x\rangle$$

The norm of this should give us the desired number but this number can be obtained by taking inner product of $|\psi\rangle\otimes |\uparrow\rangle$ with the state vector written in first equation.

I am myself confused. How do we write $\psi_{+}$ in form of innerproduct?
Can we write
$$\psi_{+} = \langle x|\psi\rangle \langle \uparrow |\alpha\rangle ?$$

Last edited:
any correction/suggestion will be helpful :)

I think the correct answer is (in terms of probability)
$$\int |\psi_{+}(\mathbf{x,t})|^2d^3 \mathbf{x}$$
I want to know if the mathematics I have done is correct. Thanks

How can I calculate the amplitude that the particle is just spin up, without any regards for its position?

There's no such quantity. You can calculate the *probability* that the particle is spin-up without regards for its position, and your expression for this probability in #3 is correct. But in general it doesn't make sense to talk about the *amplitude* for the particle to be spin-up, regardless of position. You can't just do ##\int d^3 x \psi_+(x)## because squaring this will not give you the correct probability that you wrote down in #3.

But in general it doesn't make sense to talk about the *amplitude* for the particle to be spin-up, regardless of position.
In quantum computation we do it all the time. We dont care at what position our nucleus is (in case of NMR) but we do care about the amplitudes of nucleus in spin up and down states.

Sure, I think it makes sense to define such an amplitude if ##\psi_+(x)## has essentially the same phase everywhere in space. Then I think we can define a sensible amplitude ##e^{i \phi} \sqrt{\int d^3 x |\psi_+ (x)|^2}## where ##e^{i \phi}## is the constant global phase of ##\psi_+(x)##. But if ##\psi_+(x)## is not coherent in this way I don't think you can define an amplitude to be spin up independent of position. We are tracing out the position degree of freedom and we end up with a density matrix, whose entries are probabilities and not amplitudes.


text:
# Indicating the axes [closed]

I want to scale the $x$ axis of the plot by $x^0$ and the $y$ axis by $\tan x$. Is this possible ?

 Plot[Tan[x], {x, 0, 10}, PlotRange -> Automatic]

EDIT: Actually wanted to know that how to include the axes name like in the below picture mentioned by (x and y) and the curve whiched is defiend in the picture by $f(x)=x^2$?

-

## closed as unclear what you're asking by Kuba, Artes, Sjoerd C. de Vries, The Toad♦Sep 8 '13 at 22:53

Please clarify your specific problem or add additional details to highlight exactly what you need. As it's currently written, it’s hard to tell exactly what you're asking. See the How to Ask page for help clarifying this question. If this question can be reworded to fit the rules in the help center, please edit the question.

Try looking at the help file for PlotRange. –  bill s Sep 8 '13 at 18:34
I think you cannot because Axes units must be numbers. –  Rorschach Sep 8 '13 at 18:34
I don't understand what output you want, can you clarify a bit? (One interpretation I came up with is that you want to label the axes, in which case: Plot[Tan[x], {x, 0, 10}, PlotRange -> Automatic, AxesLabel -> {Defer[x^0], Defer[Tan[x]]}] if this is not what you want can you perhaps find a picture of how you want it to look ) –  ssch Sep 8 '13 at 18:51
How is your edit related to the first sentence? –  Kuba Sep 8 '13 at 21:18
Your edit seems to ask a completely different question. The first question was interesting. This new question can be solved with a quick look at the documentation for styling plots and drawing graphics. AxesLabel -> {"x", "y"}, AxesStyle -> Arrowheads[0.05], Epilog -> Text[TraditionalForm[f[x] == x^2], {7, 6.25}] –  Timothy Wofford Sep 8 '13 at 21:39

I believe this is what you are looking for

Plot[ArcTan@Tan[x], {x, 0, 10},
Ticks -> {
Table[{i, i*180 °/π}, {i, 0, 10, π/6}],
Table[{i, N@Tan[i]}, {i, -90 °, 90 °, 10 °}]
}
]

The resulting plot has an $x$-axis marked of in degrees (my interpretation of x^0) and the $y$-axis is scaled according to ArcTan, much like LogPlot is scaled according to Exp.

-
Ahhh, 0 was \[deg] :) I think it is good interpretation :) –  Kuba Sep 8 '13 at 19:54
I have edited the question. –  user15079 Sep 8 '13 at 20:58


text:
Chapter 1, Problem 44P

### College Physics

11th Edition
Raymond A. Serway + 1 other
ISBN: 9781305952300

Chapter
Section

### College Physics

11th Edition
Raymond A. Serway + 1 other
ISBN: 9781305952300
Textbook Problem

# Given points (r1, θ1) and (r2, θ2) in polar coordinates, obtain a general formula for the distance between them. Simplify it as much as possible using the identity cos2 θ + sin2 θ = 1. Hint: Write the expressions for the two points in Cartesian coordinates and substitute into the usual distance formula.

To determine
The expressions for the two points in Cartesian coordinates and substitute into the usual distance formula.

Explanation

Given Info: The trigonometric identity is sin2θ+cos2θ=1 and (cosθ1cosθ2+sinθ1sinθ2)=cos(θ1θ2) .

Explanation:

Considering the below figure to get the Cartesian coordinates of the two points are,

x1=r1cosθ1and  y1=r1sinθ1

x2=r2cosθ2and  y2=r2sinθ2

The distance between the two points will be the hypotenuse of the shaded triangle which is given by,

(Δs)=(Δx)2+(Δy)2=(r12cos2θ1+r22cos2θ22r1r2cosθ1cosθ2)+(r12sin2θ1+r22sin2θ2

### Still sussing out bartleby?

Check out a sample textbook solution.

See a sample solution

#### The Solution to Your Study Problems

Bartleby provides explanations to thousands of textbook problems written by our experts, many with advanced degrees!

Get Started


text:
• # question_answer A person swims in a river aiming to reach exactly on the opposite point on the bank of a river. His speed of swimming is 0.5 m/s at an angle of $120{}^\circ$ with the direction of flow of water. The speed of water is A)  1.0 m/s                        B)  0.5 m/sC)  0.25 m/s             D)         0.43 m/s

Here v = 0.5 m/sec.     u=? $\sin \theta =\frac{u}{v}\Rightarrow \frac{u}{0.5}=\frac{1}{2}$or $u=0.25m{{s}^{-1}}$


text:
# A simple Mastermind game in C

Any idea to write this code more smarter and shorter? I also expect your advice about general organisation of the code.

Object of the Game

In your version of Mastermind, the computer will be the codemaker and one player will be the codebreaker. The computer picks a sequence of 4 pegs, each one being one of any of size colors.

The object of the game is to guess the exact positions of the colors in the computer's sequence in as few guesses as possible. After each guess, the computer gives you a score of exact and partial matches.

Rules

1. The sequence can contain pegs of colors: red, yellow, green, blue, white, black.
2. A color can be used any number of times in the sequence.
3. All four pegs of the secret sequence will contain a color - no blanks/empties are allowed.
4. Each guess must consist of 4 peg colors - no blanks.
5. The player has 12 guesses to find the secret sequence.

Scoring

For each of the pegs in your guess that is the correct color and in the correct position, the computer will give you one small black peg to the right of that move. If you score 4 small black pegs on a guess, you have guessed the secret sequence.

For each of the pegs in your guess that is a correct color in an incorrect position, the computer will give you one small white peg to the right of that move. Together, there will be no more than four small black and white pegs for each move.

If none of the pegs in your guess is of a correct color, you will see no small pegs to the right of that move.

Sample scoring:

Requirements:

1. The players should be able to enter four colours as their guess. When they enter their guess, then your program should display their guess and next to the guess it should display the score. Make sure that you clearly visualise the guess and also the score next to it. You do not need to use graphics as long as you display the colours properly that will be enough.
2. Different visualisation approach can be used, for example in your program when you do the computation you can assign an integer number to each colour, but then you can visualise it as follows which is based on Figure 1:

Your guess:              | Your score:
---------------------------------------------------
Blue Yellow Green Red    | Black Black White White
---------------------------------------------------
Black Yellow White Red   | Black White
---------------------------------------------------
Yellow Blue White Yellow |

3. After the player completes playing the came once (after either they win or they had 12 guesses), your program should ask the user if they would like to continue if they do then your program should generate a new code.

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

void makeCode(char secretCode[4][10])
{
int i, randColor;
for(i=0; i<4; i++)
{
randColor = 1 + rand() % 6;     //creates a number
switch(randColor)       //converts number created to a string
{
case 1: strcpy(secretCode[i], "red");       break;
case 2: strcpy(secretCode[i], "yellow");    break;
case 3: strcpy(secretCode[i], "green");     break;
case 4: strcpy(secretCode[i], "blue");      break;
case 5: strcpy(secretCode[i], "white");     break;
case 6: strcpy(secretCode[i], "black");     break;
}
}
}

void guess(char guessCode[4][10])
{
for(int i=0; i<4; i++)
scanf("%s", guessCode[i]);
}

void codeCheck(char secretCode[4][10], char guessCode[4][10], int *blackPeg, int *whitePeg)
{
int i, j, checkSecret[4] = {1,1,1,1}, checkGuess[4] = {1,1,1,1};
*blackPeg = *whitePeg = 0;

for(i=0; i<4; i++)      //if secret and guess's position and color are same, blackpeg increases and mark "check"
if(strcmp(guessCode[i], secretCode[i]) == 0)
{
++*blackPeg;
checkSecret[i] = checkGuess[i] = 0;
}

for(i=0; i<4; i++)
for(j=0; j<4; j++)
if(strcmp(secretCode[i],guessCode[j]) == 0  &&  checkGuess[i]  &&  checkSecret[j]  &&  i != j)
{// determines crushes and eliminates extra whitePegs
++*whitePeg;
checkSecret[j] = checkGuess[i] = 0;
}
}

void displayGuess(char guessCode[4][10], int blackPeg, int whitePeg)
{
int i;
for(i=0; i<4; i++)
printf("%s ", guessCode[i]);
printf("\t\t");
for(i=0; i<blackPeg; i++)
printf("black ");
for(i=0; i<whitePeg; i++)
printf("white ");
printf("\n\n");
}

int main()
{
srand(time(NULL));
int i, option=1, blackPeg, whitePeg, wrongGuess;
char secretCode[4][10], guessCode[4][10];
while(1)
{
printf("MASTER MIND! \nPress 1 to start game \nPress any number to exit\n\n");
scanf("%d", &option);
if(option == 1)
{
makeCode(secretCode);
for(wrongGuess=1; wrongGuess<=12; wrongGuess++)      //gives 12 rights to guess
{
guess(guessCode);
codeCheck(secretCode, guessCode, &blackPeg, &whitePeg);
displayGuess(guessCode, blackPeg, whitePeg);
if(blackPeg == 4)           //if player guess correct all, than the game finishes
{
printf("You Win!\n\n\n\n");  break;
}
}
if(wrongGuess == 13)        //if player cannot guess correct colors in 12 rounds, he losts
printf("\nYou Lost!\nSecret Code: %s %s %s %s\n\n\n\n\n", secretCode[0], secretCode[1], secretCode[2], secretCode[3]);
}
else
exit(1);
}
}

• Can you please copy the text? Text in an image is not searchable. – BCdotWEB Aug 10 '16 at 13:22
• Holy crap I played this game as a kid and I just now realized that the Fallout 3/4 style of computer terminal hacking is very very similar to this game. – Kyle Falconer Aug 10 '16 at 14:02

The Good
The choice of variable and function names is very descriptive. The code is properly indented but. The consistent use of camelCode is excellent.

MAGIC NUMBERS
The term Magic Numbers refers to numerical constants in the code. A good programing practice is to used named constants rather than numbers. Named constants make the code more self documenting, and allow easier modification of the code. When a named constant is used the code only needs to be changed in one location rather than multiple locations. An example of this in the code would be to increase or decrease the size of the arrays.

Example Named Constants:

#define ARRAY_SIZE    4
#define STRING_SIZE   10
#define RED           1
#define YELLOW        2
#define GREEN         3
#define BLUE          4
#define BLACK         5
#define WHITE         6
#define MAX_GUESS     12

void makeCode(char secretCode[ARRAY_SIZE][STRING_SIZE])
{
int i, randColor;
for(i=0; i<ARRAY_SIZE; i++)
{
randColor = 1 + rand() % 6;     //creates a number
switch(randColor)       //converts number created to a string
{
case RED:
strcpy(secretCode[i], "red");
break;
case YELLOW:
strcpy(secretCode[i], "yellow");
break;
case GREEN:
strcpy(secretCode[i], "green");
break;
case BLUE:
strcpy(secretCode[i], "blue");
break;
case BLACK:
strcpy(secretCode[i], "white");
break;
case WHITE:
strcpy(secretCode[i], "black");
break;
}
}
}

void displayGuess(char guessCode[ARRAY_SIZE][STRING_SIZE], int blackPeg, int whitePeg)
{
int i;
for(i=0; i < ARRAY_SIZE; i++)
printf("%s ", guessCode[i]);
printf("\t\t");
for(i=0; i<blackPeg; i++)
printf("black ");
for(i=0; i<whitePeg; i++)
printf("white ");
printf("\n\n");
}

Note: The code above would be more efficient if you had an array of color strings and indexed into the the array using randColor as follows:

void makeCode(char secretCode[ARRAY_SIZE][ARRAY_SIZE])
{
int i, randColor;
char *secretCodeColors[] =
{
"red",  // Multiple lines used to make it easier to add colors.
"yellow",
"green",
"blue",
"black",
"white",
};

for(i=0; i<4; i++)
{
randColor = rand() % 6;
strcpy(secretCode[i], secretCodeColors[randColor]);
}
}

Not only does it make the function shorter, but indexing into the array is faster than the switch statement.

@MegaTom is correct, this code would be better using enums or named constants. The string compares are much less efficient that integer compares.

Multiple Statements on a Line
To make future modifications easier, there should never be multiple statements on a single line. Let's say some code needed to be added to each case in the switch statement. Each of the cases in the switch statement would then be need to be broken into multiple lines which makes the edit more complex, and can create typos during the edit. It is much easier to just add another statement by adding a single line, rather than trying to add it to a single line.

            case 1: strcpy(secretCode[i], "red");       break;
case 1:
strcpy(secretCode[i], "red");
break;

Generally it is better to assume that code will need to edited at some time in the future to add features or fix bugs.

Prefer return() over exit()
In the case of this program since there is no error checking there is no reason to use either exit() or return(). If there is error handling in the program, the exit() function should only be used if the program encounters an error it can't correct deep in multiple function calls. The exit() function should only be used in stand alone programs, never in operating systems code. When using the exit() function, use the macros EXIT_SUCCESS and EXIT_FAILURE that are defined in stdlib.h.

Don't Repeat Yourself
When code is repeating itself, it is better to write another function rather than repeating the code. Then the code only needs to be written and debugged once rather than multiple times. This is know as the DRY principlein software engineering.

Example: The following code has loops that repeats that

void displayGuess(char guessCode[ARRAY_SIZE][STRING_SIZE], int blackPeg, int whitePeg)
{
int i;
for(i=0; i < ARRAY_SIZE; i++)
printf("%s ", guessCode[i]);
printf("\t\t");
for(i=0; i < blackPeg; i++)
printf("black ");
for(i=0; i < whitePeg; i++)
printf("white ");
printf("\n\n");
}

void showPeg(int pegCount, char *colorString)
{
for (i = 0; i < pegCount; i++)
printf(colorString);
}

void displayGuess(char guessCode[ARRAY_SIZE][STRING_SIZE], int blackPeg, int whitePeg)
{
int i;
for(i=0; i < ARRAY_SIZE; i++)
printf("%s ", guessCode[i]);
printf("\t\t");
showPeg(blackPeg, "black ");
showPeg(whitePeg, "white ");
printf("\n\n");
}

Decrease Function Complexity
Another software engineering principle is the Single Responsibility Principle. A function should only be responsible for one action, this makes each function easier to read, write, debug and use multiple times. It is much better to write smaller more concise functions() so that the can be used in multiple places and only need to be debugged once. The functions codeCheck() and main() would both benefit from applying this principle.

The program should guide the user better. It's not clear what the input should be, there should be prompts for each input. The program might be more fun if the user could enter colors rather than numbers.

• Thank you so much for your detailed and clear answer. I m grateful to you. @pacmaninbw – user302686 Aug 10 '16 at 18:29
• I think that in this case the "magic numbers" were better than the consents. Defining a constant and only using it once seams like a bad idea. The array approach is definitely better, so +1. – MegaTom Aug 10 '16 at 18:45

Good job on the code. This is better then I did the first time I tried this problem. But I do see three big problems:

### 1. Stores codes as strings

I think that it would be best to use a number/enum for the color, not a string. This will use less memory and simplify comparing later, as well as basically fixing problem 2.

### 2. Silently fails on invalid colors

As your code stands, a player may put in invalid colors and will not get a warning. So if i guess bleu purple gray orange, it will say I got nothing, and continue. I think it would be better to tell the user that they are guessing invalid colors. (This is made even worse by the fact that the user is not told what colors are good in the first place.) If you validate as they enter the colors that they entering valid colors, that can fix the problem.

### 3. Case sensitive

Red RED Green Black will fail the comparison the same way as above, because you use strcmp, not strcmpi.

• strcomp will not compile. – pacmaninbw Aug 10 '16 at 15:16
• @pacmaninbw typo, sorry. Error has been fixed in edit. – MegaTom Aug 10 '16 at 15:17

You should replace your Defines with an enum, defines just copy and paste shit, enums are actually part of the language.

Also, your spacing makes it a bit more difficult to read, but I've seen much worse.


text:
## CryptoDB

### Paper: To Label, or Not To Label (in Generic Groups)

Authors: Mark Zhandry , NTT Research & Princeton University Search ePrint Search Google Slides CRYPTO 2022 Generic groups are an important tool for analyzing the feasibility and in-feasibility of group-based cryptosystems. There are two distinct wide-spread versions of generic groups, Shoup's and Maurer's, the main difference being whether or not group elements are given explicit labels. The two models are often treated as equivalent. In this work, however, we demonstrate that the models are in fact quite different, and care is needed when stating generic group results: - We show that numerous textbook constructions are \emph{not} captured by Maurer, but are captured by Shoup. In the other direction, any construction captured by Maurer \emph{is} captured by Shoup. - For constructions that exist in both models, we show that security is equivalent for single stage'' games, but Shoup security is strictly stronger than Maurer security for some multi-stage'' games. - The existing generic group un-instantiability results do not apply to Maurer. We fill this gap with a new un-instantiability result. - We explain how the known black box separations between generic groups and identity-based encryption do not fully apply to Shoup, and resolve this by providing such a separation. - We give a new un-instantiability result for the \emph{algebraic} group model.
##### BibTeX
@inproceedings{crypto-2022-32203,
title={To Label, or Not To Label (in Generic Groups)},
publisher={Springer-Verlag},
author={Mark Zhandry},
year=2022
}


text:
Vol. 4, No. 5, 2009

 Download this article For screen For printing
 Recent Issues
 The Journal Cover Editorial Board Research Statement Scientific Advantage Submission Guidelines Submission Form Subscriptions Author Index To Appear ISSN: 1559-3959
An endoscopic grasper with corrugated plate-shaped tactile sensors

Mohammad Ameen Qasaimeh, Mohammadreza Ramezanifard and Javad Dargahi

Vol. 4 (2009), No. 5, 913–926
Abstract

One of the major weaknesses in current endoscopic surgery is the lack of tactile feedback. This paper reports on the design, finite element modeling, and experimental testing of a corrugated tactile sensor. The sensor, a miniaturized and modified form of our previously developed tactile sensor, consists of a 75 $\mu$m plate-shaped silicon layer and a 25 $\mu$m polyvinylidene fluoride (PVDF) film, patterned on both sides using photolithographic techniques to form three independent sensing elements. The sensor is 15 mm long, 7.5 mm wide, and approximately 3 mm thick, which could make it versatile enough for integration with current endoscopic and medical robotics manipulators. The silicon layer is micromachined in such a way that a U-channel is formed. When a force is applied on the tactile sensor, output voltages from the patterned PVDF-sensing elements are combined to obtain tactile information. Results show that the sensor exhibits high sensitivity and can measure small dynamic loads, comparable to a human pulse, as well as large grasping forces. In addition to measuring the magnitude and position of the applied load, the sensor can determine the modulus of elasticity of the grasped object.

Keywords
tactile sensor, endoscopic grasper, minimally invasive surgery, microfabricated sensor
Milestones
Received: 12 May 2008
Revised: 18 April 2009
Accepted: 17 May 2009
Published: 5 September 2009
Authors
 Mohammad Ameen Qasaimeh Biomedical Engineering Department McGill University 740 Dr. Penfield Avenue Montreal, QC  H3A 1A4 Canada Mohammadreza Ramezanifard Department of Mechanical and Industrial Engineering Concordia University 1455 De Maisonneuve Blvd. W Montreal, QC  H3G 1M8 Canada Javad Dargahi Department of Mechanical and Industrial Engineering Concordia University 1455 De Maisonneuve Blvd. W Montreal, QC  H3G 1M8 Canada


text:
# Joint distribution of two marginal normal random variables

Question: Suppose we have: \begin{align*} \begin{bmatrix} X_1 \\ X_2 \end{bmatrix} \sim N\left(\begin{bmatrix} 6 \\ 3 \end{bmatrix}, \begin{bmatrix} 12 & 3 \\ 3 & 2 \end{bmatrix} \right) \end{align*} and let $Y = X_1 - 3X_2$, then what is the joint distribution of $X_1$ and $Y$?

My working: The marginal distribution of $X_1$ is: \begin{align*} X_1 \sim N(6, 12) \end{align*}

The marginal distribution of Y is: $$Y \sim N\left(-3, 12 \right)$$ since \begin{gather*} E\left(Y\right) = 6 - (3)(3) = -3 \\ V\left( Y\right) = 12+ (-3)(2)(-3) + 2(3)(-3) = 12 \end{gather*}

So we have $X_1 \sim N\left(6, 12\right)$ and $Y \sim N\left(-3, 12\right)$, first we need to work out the covariance between $X_1$ and $Y$: \begin{align*} cov\left(X_1,Y\right) & = E(X_1Y) - E(X_1)E(Y) \\ & = E\left(X_1\left(X_1-3X_2 \right) \right) - 6(-3) \\ & = E(X_1^2) - 3E(X_1X_2) + 18 \\ & = V(X_1) + E(X_1)^2 -3\left[cov(X_1, X_2) + E(X_1)E(X_2) \right] + 18 \\ & = 12+36-3\left[3+(6)(3) \right] + 18\\ & = 3 \end{align*} Hence, the joint distribution between $X_1$ and $Y$ is given by: \begin{align*} \begin{bmatrix} X_1 \\ Y \end{bmatrix} \sim N\left(\begin{bmatrix} 6 \\ -3 \end{bmatrix}, \begin{bmatrix} 12 & 3 \\ 3 & 12 \end{bmatrix} \right) \end{align*}

Query:

I feel my answer is not right because I assumed that if we have two marginal normal random variables, say, $X_1 \sim N(\mu_1, \Sigma_{11})$ and $X_2 \sim N(\mu_2, \Sigma_{22})$, then $X_1$ and $X_2$ is jointly normal. That is,

\begin{align*} \begin{bmatrix} X_1 \\ X_2 \end{bmatrix} \sim N\left(\begin{bmatrix} \mu_1 \\ \mu_2 \end{bmatrix}, \begin{bmatrix} \Sigma_{11} & cov(X_1, X_2) \\ cov(X_1, X_2) & \Sigma_{22} \end{bmatrix} \right) \end{align*} where $cov(X_1, X_2)$ denotes the covariance between $X_1$ and $X_2$.

However, I know in general just because $X_1$ and $X_2$ are both marginally normal, this does not mean they are jointly normal. How else can I find the joint distribution between $X_1$ and $Y$?

Thanks

If a random vector $X$ is normal $(M,\Sigma)$ then, for every matrix $A$, $AX$ is normal $(AM,A\Sigma A^T)$.
In your case, $A=\begin{pmatrix}1 & 0\\ 1 & -3\end{pmatrix}$ and $X=\begin{pmatrix}X_1\\ X_2\end{pmatrix}$ yield $AX=\begin{pmatrix}X_1\\ Y\end{pmatrix}$ hence you simply must compute the mean vector $AM$ and the covariance matrix $A\Sigma A^T$.
Note that the hypothesis in this exercise is not that $X_1$ and $X_2$ are normal but that the random vector $X=\begin{pmatrix}X_1\\ X_2\end{pmatrix}$ is normal. In the former situation, you are right to stress that chaos could ensue, but not in the latter.
• Great. ${}$  – Did Oct 18 '13 at 7:21


text:
The Tutte polynomial and toric Nakajima quiver varieties

Abstract

For a quiver $Q$, we take $M$ an associated toric Nakajima quiver variety and $\Gamma$ the underlying graph. In this article, we give a direct relation between a specialisation of the Tutte polynomial of $\Gamma$, the Kac polynomial of $Q$ and the Poincaré polynomial of $M$. We do this by giving a cell decomposition of $M$ indexed by spanning trees of $\Gamma$ and ‘geometrising’ the deletion and contraction operators on graphs. These relations have been previously established by Sturmfels-Hausel and (Crawley-Boevey)-Van den Bergh, however the methods here are more hands-on.

Type
Publication
arXiv preprint arXiv:1910.01633
Date


text:
×

# Stuck in Remainders!

Consider the following division, $\frac{x+1}{2x+2}=\frac{\frac{1}{2}(2x+2)}{2x+2}=\frac{1}{2}$ So, dividing $$x+1$$ by $$2x+2$$ leaves no remainder. [Of course, $$x$$ cannot be $$-1$$ here.]

Now, substituting $$x=4$$ in the expressions gives us two integers 5 and 10. But, $5=0 \times 10 +5$ We're getting 5 as a remainder now!

Why are these two ways of defining remainders not congruent?

Note by Atomsky Jahid
2 months, 2 weeks ago

Sort by:

Even though the same word "remainder" is used, you have to bear in mind what the definition in each of these contexts are. Staff · 2 months, 1 week ago

@Brian Charlesworth Would you help me with this? · 2 months, 1 week ago

With proper fractions, (i.e., where the numerator is strictly less than the denominator), the remainder is just the numerator itself, so in your general case,

$$x + 1 = 0 \times (2x + 2) + (x + 1)$$,

i.e, $$x + 1$$ divided by $$2x + 1$$ is $$0$$ with remainder $$x + 1$$. Defined this way, a proper fraction does have a remainder, which avoids the contradiction you mention. · 2 months, 1 week ago

I understand your definition. But, is it the proper one? What I've found in the Wikipedia is the following.

"Given two polynomials f(x) (the dividend) and g(x) (the divisor), asserts the existence and the uniqueness of a quotient q(x) and a remainder r(x) such that $f(x)=q(x)g(x)+r(x) ; and, r(x)=0 ,or, deg(r) < deg(g)$"

But, $$2x+2$$ and $$x+1$$ both are first-degree polynomials!

Again, I solved some problems where I had to resort to the algebraic manipulation I mentioned in this note.

In an algebra problem, I had to do the following. $R(x)=x^5+\frac{1}{2}x^3+x^2-\frac{1}{2}x+\frac{5}{2}$ $R(x)=(x^2-\frac{1}{2})(x^3+x+1)+3$ $R(x)=x^2(x^3+x+1)-\frac{1}{2}(x^3+x+1)+3$ Then, I had to say $$R(x)$$ divided by $$x^3+x+1$$ leaves a remainder of 3.

So, basically we cannot incorporate your definition, can we? · 2 months, 1 week ago

Does the Wikipedia definition assume the $$deg(f) \gt deg(g)$$? In any event, it also depends on what field we're working with. If we are working with rationals we can indeed say that $$x + 1 = \dfrac{1}{2}(2x + 2) + 0$$, which satisfies the Wikipedia definition.

In your example where you substituted $$x = 4$$, this would translate to $$5 = \dfrac{1}{2} \times 10 + 0$$, but this is not how we normally deal with remainders over the integers, so I think this is the source of the "incongruence" you mention in your question.

(If $$deg(f) \lt deg(g)$$ then we would necessarily have $$q(x) = 0$$ and $$r(x) = f(x)$$, in which case the Wikipedia definition would be satisfied.) · 2 months, 1 week ago

In our case $$deg(f) = deg(g)$$. And, the definition assumes $$deg(f) \geq def(g)$$. [This is also the case in Brilliant wiki about polynomial division.]

I also forgot to mention one thing about your first comment. You said, "where the numerator is strictly less than the denominator". But, notice that $$x+1$$ is strictly greater than $$2x+2$$ $$\forall x < -1$$. · 2 months, 1 week ago


text:
# No Cubic Discriminant Involved

Algebra Level 4

Find the number of integral values of $k$ such that the equation $x^3-27x+k=0$ has at least 2 integral roots of $x$.

×