text:
Programing tasks for the theory of algorithms (BMETE91AM47/TA - 2018/19/2)

Oktató:
Kurzus típus:
Elmélet
Nyelv:
angol
Félév:
2018/19/2

The aim of this subject is to maintain the programming skills of the students through the solution of the programming tasks related to the Theory of Algorithms, and at the same time to facilitate a better understanding of the algorithms and the efficiency and complexity of them.

  I encoded this program myself, did not copy or rewrite the code of others,
and did not give or send it to anyone else.

Signature

You have to follow the next rules. You must not submit or look at solutions or program code that are not your own. It is an act of plagiarism to submit work that is copied or derived from the work of others and submitted as your own. You must not share your solution code with other students, nor ask others to share their solutions with you. You must not ask anybody to write code for you. Many forms of collaboration are acceptable and even encouraged. It is usually appropriate to ask others for hints and debugging help or to talk generally about problem solving strategies and program structure. In fact, we strongly encourage you to seek such assistance when you need it. Discuss ideas together, but do the coding on your own.

Contents

1. Pattern matching (2019-02-16 24:00)
2. Nondeterministic finite automaton (2019-02-23 24:00)
3. Breadth first search (BFS) (2019-03-02 24:00)
4. Finding left derivation (2019-03-09 24:00)
5. Effective verifier (2019-03-16 24:00)
6. Euklidean algorithm (2019-03-30 24:00)
7. Brute force (2019-03-30 24:00)
8. Integer programming (2019-04-16 24:00)
9. Bin packing (2019-04-24 24:00)
10. Acrobats (2019-05-02 24:00)
11. Union of intervals (2019-05-11 24:00)
12. Binary search tree (2019-05-19 24:00)

1. Pattern maching

• Write a program for comparing the simple matching and the quick search algorithms!
1. The input for the program is given in a terminal command. For Python 2 it looks like
python 1AdrianSmith.py text.text pattern

for Python 3 it is like

python3 1AdrianSmith3.py text.text pattern

The program read the file text.text and search for the first occurrence of the given pattern in it. The command arguments can be read out from the inbuilt array sys.argv:

import sys

print('The name of the file ' + sys.argv[1] + ', the pattern is ' + sys.argv[2])

(The sys.argv[0] contains the name of the program.)

2. For reading a file use the file functions, e.g.
f = open(filename, 'r')
f.close()

The strip() method cut down the unnecessary starting and endig white spaces.

3. In your program you do not need to check if the specified text file exists or whether it actually contains text. The pattern is always at most as long as the text. The text contains lowercase letters of the English alphabet a-z and spaces. There are only lowercase letters in the pattern, but no spaces. According to the algorithms, the program allows the comparison of a single character of the text and the pattern, but does not use the Python string functions except the len() function.
4. Your program have to run the simple matching and the quick search algorithms with the given text and pattern. The output of the program specifies whether the pattern is in the text, at which character position and how many comparisons have been made to the first occurrence:
Simple matching made 2610 comparison(s), the pattern is at 2321
Quick search made 270 comparison(s), the pattern is at 2321

Specify the number of comparisons even if the pattern does not appear in the text:

Simple matching made 2610 comparison(s), no pattern in the text
Quick search made 270 comparison(s), no pattern in the text

• If in Python2 you take a comma after a print command, the output of the next print will be continued in the same line. For this effect in Python 3 use the end option like in print("Hello", end="").
• Try your program with the next downloadable text files and with the given patterns (of course in the test phase of your program, you may use your own very simple text files and patterns):
File Pattern
1.text overscrupulous
1.text zombies
2.text aaaaaaaaa
2.text bbbbbbbbb
2.text aaaaaaaab
2.text aaaaaaaba

2. Nondeterministic finite automaton

• The program automaton.py simulates the running of a simple non-deterministic finite automaton.
python automaton.py word

or with

python3 automaton.py word

where word is the word you want to recognize.

2. The program uses the built-in set function to keep records of the currently available states in the computing tree of the non-deterministic finite automaton.
3. Draw the automaton and explain it with your own words: (1) how does the program simulate the operation of the automaton, (2) what language does the automaton recognize? (In the e-mail please answer these two questions, but no need to attach a drawing.)
• Change the description of the automaton in the file automaton.py between the lines
# the description of the automaton starts here

and

# the description of the automaton ends here

so that the program accepts the words that contain even number of letters a or contain the string algel (or both)! So e.g. 'aaalgelbbb' and 'asdaefaa' are accepted but 'aaalgbb' is not.

• Using the Breadth first search (BFS) algorithm known from the subject Combinatorics 1, we can find the shortest possible path in a graph between two given vertices. The task is to program this algorithm.
• The input of the algorithm is a simple directed graph, which is defined as follows in a text (.text) file:
1. The first line of the file contains the natural numbers $N$, $M$, $S$, $T$ separated by spaces.
• The set of vertices of the simple directed graph $\vec{G} = (V, \vec{E})$ is $V = \{0, 1, 2, \ldots, N-1\}$.
• The number of edges is $\left| \vec{E} \right| = M$.
• We would like to find the shortest directed path from the vertex $S \in V$ to the vertex $T \in V$ ($S \ne T$).
2. The next $M$ lines contain "$U_i$ $V_i$" pairs of numbers. Such a pair represent the edge $(U_i, V_i) \in \vec{E}$. An edge appears only once in the file.
3. If there is a path from $S$ to $T$, the program lists the vertices starting with $S$ and finished with $T$. If there is no path, it prints out "no path".
• As a help we give a file graph.py, where we provide the input function of the graph and the output function of the path. So the search function search_path has to be written.
1. The first parameter of this funcion is graph. This is the edge-list representation of the graph. The edge-list is given in a dictionary, where a list is belonging to every vertex. The elements in the list are vertices available by the outgoing edges. For example look at the graph of 6 vertices and 8 edges given in the next file
6 8 2 5
1 0
2 1
3 2
1 3
0 5
2 4
4 5
4 3

The next edge-list belongs to this graph

graph = {0: [5], 1: [0, 3], 2: [1, 4], 3: [2], 4: [5, 3], 5: []}

2. The next parameter of the function from_where gives the first vertex $S$ and the third parameter to_where gives the last vertex $T$.
3. You may use the read_path function, which read out a path from a (not necessarily complete) BFS-tree between the from_where and to_where vertices. The BFS-tree is given in the parent dictionary, where the value assigned to a vertex is the number of its parent in the tree. For example in the case of
parent = {1: 2, 4: 2, 0: 1, 3: 1, 5: 4}
from_where = 2
to_where = 5

the shortest path is [2, 4, 5].

4. When implementing the algorithm, it is not necessary to split the edges into classes (forward, backward,...), and not necessary to search in the whole graph, it is enough to find one shortest path.
5. Buil-in list functions like append and pop(0) can be used to implement a queue. (But one may try the modul Queue in Python 2 or the modulqueue in Python 3.)
• Test your program on the files graf1.text and graf2.text files, but also on other self-made input files!

4. Finding left derivation

• The breadth first search is suitable for deriving a word in a context-free grammar.
1. Consider the CF grammar $G=(V,\Sigma,R,S)$, and construct the directed graph $\vec{G}=((V\cup\Sigma)^*,\vec{E})$ where the vertices are the strings of terminal and non-terminal symbols. This graph has countably infinite number of vertices, but it is enough to search in a finite part of it for finding a derivation of a word.
2. The graph $\vec{G}$ contains the edge $(\alpha, \beta)$ if and only if there is a left-derivation step from the string $\alpha \in (V \cup \Sigma)^*$ to the string $\beta \in (V \cup \Sigma)^*$, in other words we get $\beta$ if we apply a substitution rule from $R$ on the first non-terminal symbol of $\alpha$. Formally \begin{equation*} (\alpha, \beta) \in \vec{E} \Longleftrightarrow \exists w \in \Sigma^* \; \exists \gamma, \delta \in (V \cup \Sigma)^* \; \exists A \in V \colon (A \rightarrow \delta) \in R, \alpha = wA\gamma \textrm{ and } \beta = w\delta\gamma. \end{equation*}
3. In this graph the left derivations of the word $w \in L(G)$ are exactly the $S \leadsto w$ paths, where $S \in V$ is the start variable. All edges of a path correspond to a rule applied on the leftmost non-terminal symbol. We want to find such a path in this task.
• We give the skeleton of the program in the file CF.py. The only command line argument of this program is a word to derive. The prgram prints out the derivation to the standard output.

The separation of the terminal and non terminal symbols is solved by a simple method: all capital letters A to Z of the English alphabet are possible non-terminal symbols while all other characters are terminal.

1. The CF grammar is represented by the class Grammar. The start symbol is given to the constructor argument start_variable. Complete the add_rule method such that it adds the left and right side of a rule to the language. If necessary, modify the __init__ constructor creating a suitable data structure to store the rules.
2. The derive method gets a word as a parameter and returns a left derivation in a list. If there is surely no such derivation, it returns False. To do this, it uses the breadth first search (presented in the previuos task) algorithm realized by the private function _bfs_search. Because the graph is now infinite, we can not list all edges. Instead, we use the _next method producing a list of vertices that can be reached on an edge from the string vertex in the graph.

Complete the _next method such that it returns a list of words which are available from the received string vertex by a single left derivation rule. For example, if the grammar is \begin{equation*} S \to aSB \mid bSA \mid \epsilon, \quad A \to aA \mid \epsilon, \quad B \to bB \mid \epsilon, \end{equation*} then

self._next('aSbbB') == ['aaSBbbB', 'abSAbbB', 'abbB']

3. Let's try the program and find derivation to some given words. Please, answer the following two questions in the email! What language is specified in the file CF.py? What happens when we give a word to the program that is not in the language?
• A non mandatory task: in the breadth first search, there are very many vertices of the graph $\vec{G}$ we construct and walk through untill we can find a way to the given word. How could we make our program more effective by decreasing the tree constructed (this part no longer has to be programmed)!

5. Effective verifier

• The task in this week is to write a Python program that implements an effective verifier algorithm deciding on a given graph that a given sequence of numbers represents a Hamiltonian cycle in the graph. (This task is preparing for a later topic in Algorithm theory where you will learn that the language HAM of graphs containing Hamiltonian cycles is in NP.)
• It is easy to decide for a graph and a sequence of numbers that the sequence forms a Hamiltonian cycle in the graph – one just have to check that each vertex occurs exactly once and there are edges between each pair of consecutive vertices, and between the first and last vertex.
• The program receives the input in the form of command line arguments. For Python 2, you can run the program with the command

for Python3

• The first input (in the example graf.text) is a non directed simple graph that we enter in a text (.text) file
1. There are two natural numbers separated by spaces in the first line $N$ and $M$ where
• the simple graph $G = (V, E)$ has $N$ vertices, namely $V = \{0, 1, 2, \ldots, N-1\}$,
• and has $M$ edges, that is $\left| E \right| = M$.
2. The next $M$ lines of the file contains pairs of numbers $U_i, V_i$. One such pair corresponds to a (non directed) edge $(U_i, V_i)$. Every edge is listed only once in the file.
3. To process the input we recommend modifying the code of the appropriate part of the 3rd task. Note that the first line of the file here does not contain the vertices $S$ and $T$. Since the edges of the graph are not directed, you may want to add edges to the edge list of both endpoints!
• The second input of the program is a sequence of integers. The task of the program is to decide whether the sequence of numbers represents a Hamiltonian cycle in the graph (verify whether the sequence is a witness of the existence of a Hamiltonian cycle).
• If it is a Hamiltonian cycle (a witness) print the text
Hamiltonian cycle

otherwise print

Not a Hamiltonian cycle

• Try the program with the file graf.text and with the next input files:
Filename Expected output
t1.text Hamiltonian cycle
t2.text Not a Hamiltonian cycle
t3.text Not a Hamiltonian cycle
t4.text Not a Hamiltonian cycle
t5.text Hamiltonian cycle
t6.text Not a Hamiltonian cycle
t7.text Not a Hamiltonian cycle

6. Euklidean algorithm

• The Euclidean algorithm, or Euclid's algorithm, is an efficient method for computing the greatest common divisor of two numbers. If the input $a, b \in \mathbb{Z}^+$ are two binary numbers, then the length of input is $O(\log a + \log b)$, and the Euclidean algorithm calculate the value $\mathop{\mathrm{lnko}}(a, b)$ in at most $O(\log a + \log b)$ steps.
• In the file euklidean.py a part of a program is given which plot the heat map of the function $\log a + \log b$ on the $(a, b)$ coordinate-plane with the matplotlib Python package. The values of $a$ and $b$ are the integer numbers between $1$ and $100$. The heat map shows the value of the numbers with the colors of the rainbow (violet, indigo, blue, green, yellow, orange, red). The older versions of the matplotlib package uses violet for small and red for big numbers, but in the new versions the colors are changing from violet to yellow only.
• Modify the program to show the running of the euclidean algorithm! Plot three heat maps side by side in a window similar to one of the following. With the new version of matplotlib installed on your computer the result of the home work looks like this:

with the old version like this

The following functions should be shown on the heat maps:

1. The first heat map shows the function $\log_2 a + \log_2 b$, which is generated by the program downlaodable above.
2. The second heat map shows the number of steps of the Euclidean algorithm on each pair $(a, b)$. On the number of steps we mean: how many divisions with reminder made on $(a_i, b_i)$ pairs or decide to stop.
3. The third heat map shows the value $\mathop{\mathrm{lnko}}(a, b)$.
• The subplot function of matplotlib package can be used to display multiple figures. The argument of this function is a 3-digit number $nmk$, where the $n$ is the number of rows, $m$ is the number of columns of subfigures on the canvas. The third $k$ is the index of the subfigure, which starts at 1 in the upper left corner and increases to the right. For example
plt.subplot(132)

means that the canvas has 3 subfigures in a row, and all the results of the function calls of plt appear on the second subfigure.

7. Brute force

• One possible way to solve NP-complete problems is to use "brute force." In this approach, we generate all possible witnesses according to the input and check them one by one. If we find a good witness, then the input is in the tested language, but if none of the generated witnesses are good, then the input is certainly not an element of the language. Of course, we cannot expect this procedure to solve the problem in polynomial time.
• The language $\textrm{IND}$ consists of pairs $(G, k)$ where a simple non-directed graph $G$ has $k$ independent vertices (an independent set is also called stable set, coclique or anticlique). It is a good witness for $(G, k) \in \textrm{IND}$ if there is a set $F \subseteq V(G)$ of $k$ independent vertices. If $|V(G)| = n$, then it is possible to decide in $O(n^2)$ time on a set $F$ of points if there is no edge between the points of $F$.
• Write a program that determines whether $(G, k)$ is in the $\textrm{IND}$ language. $G$ and $k$ is described in a file given in a command line argument. If you find an independent $k$-element vertex set, write it to the standard output. Otherwise indicate that there is no independent set of $k$ elements in the graph.
1. In the file ind.py a function read_graph is given which read the edges of $G$ and the number $k$ from the file given in the command line argument. The format of the input file and the return values described in the docstring of the source code.
2. Generate all $k$-element combinations of the vertex set $\{0, 1, \ldots, n - 1\}$ of the graph and decide if any of them is independent. Stop the search if you find an independent set and write it to the standard output. If there is no independent set indicate on the standard output that there is no independent $k$-set.
3. To help coding we provide the function combinations which write the 3-element combinations of the set $\{0, 1, \ldots, 9\}$ to the standard output using the itertools package. (Of course, use the ideas of this function only, not the function itself.)
• Try your program with the next files! For the inputs belonging to the language $\textrm{IND}$ we give an independent set as a verifier. Of course any other independent set will be accepted as a witness.
File Independent set
ftln1.text 1 2 7
ftln2.text no
ftln3.text 0 4 9 11 12 14 19
ftln4.text no
ftln5.text 2 5 18 29 39
ftln6.text no

8. Integer programming

• Another known method for solving NP-complete problems is to bring the problem back to another well-known NP-complete problem. If we have an effective heuristic solver for a well-known problem, we can usually achieve better results than with brute force. In this exercise, we slightly extend the previous week's IND problem, and solve the MAXIND problem using integer linear programming tools. In IND we had to decide if a $k$-set of vertices is independent in a given graph or not. In MAXIND we have to find the max value of $k$ for which an independent $k$-set exists. We solve the integer linear program with the PuLP Python package. Install it with the built-in package manager pip or pip3 using the command
pip install pulp

• In the file pulpexample.py we give a simple example for solving the integer programming problem \begin{align*} \max\, x_0 + x_1,\\ \text{where } x_0, x_1 \in \mathbb{Z},\\ x_0 \ge 0, \\ x_1 \ge 0, \\ 2 x_0 + x_1 \le 10, \\ x_0 + 2 x_1 \le 10, \end{align*} and write out the solution to the standard output. Let's study this program! The PuLP package documentation can help you understand it.
• Let's write a program to solve the MAXIND problem!
1. Read the input of the problem, that is the simple non-directed graph $G$ and $k$ from a file having the same format as in the previous exercise, although $k$ will not be used here. As with the previous task, the program will receive the file name as a command line argument.
2. Let's define MAXIND as an integer programming task.
3. Program the integer programming problem with the PuLP package and call the solver. (Make sure that both the problem and the variables are given a unique name which is a character string, because PuLP identify them in this way when they are given to the external solver. If the names of the variables are not unique, we will receive an error message.)
4. Write the size of the maximum independent set and the elements of such a set to the standard output. PuLP returns the value of the objective function as a floating-point number, so round it before printing.
• Run the program with the inputs in the previous task. Although we are now solving a more demanding task, the files ftln2.text, ftln4.text, ftln6.text show that integer programming is much faster than brute force.

9. Bin packing

• In the bin packing task, we have to determine the minimum number of $1$ capacity bins into which taken the given $(s_i)_{i = 1}^n$, $(0 < s_i \le 1)$ weights fit. The problem is NP-complete, so an effective solution (according to our current knowledge) is not available, but several approximation algorithms have been created for it. In this task, the aim is to examine some approximate heuristics.
• In the file binPack.py we have provided a framework program that examines the lower limit and three approximation algorithms for the bin packing problem at a given input:
1. The value of OPT is the ceiling of (the smallest integer greater than) the total weight of objects, which is the lower limit for the required number of bins.
2. The first-fit (FF) algorithm puts all packs in the first bin where it fits.
3. The first-fit decreasing (FFD) algorithm is similar to FF, but first it sorts the packs in descending order.
4. The best-fit (BF) algorithm puts all objects in the bin where the least space is left. (This is already written in the program, study it.)
• Modify the binPack.py file and finish the program!
1. Implement the first_fit_pack function of the FF algorithm.
2. Implement the ffd_pack function of the FFD algorithm. Be careful as Python passes the lists by reference so that if the list of weights is sorted, it directly modifies the original list. Instead, work with a copy of the list.
3. In the program a list named packs is given. Change it for a list of random 1000 element list of numbers between 0 and 1, and call the packing functions with these values.
• Run the program a few times! Compare, how the algorithms work on the generated random inputs!

10. Acrobats

• Circus acrobats are standing on each other's shoulders to create a larger tower (there will be only one acrobat on each level in the tower). For aesthetic and practical reasons, one person's shoulders can stand only lower and lighter acrobat. Our task is to determine the number of possible most people in a tower.
• In the file acrobat.py we have provided an example program that reads the acrobats from the file named in the command line argument, and then prints them in a non-incremental order to the standard output. The file format is as follows:
1. The first line of the file contains a single positive integer $N$, the number of acrobats.
2. The file $i + 1$-st line gives the height and weight of the $i$-th acrobat.
3. The function read_acrobats reads the data of acrobats and returns with the list of Acrobat class instances. The acrobats have the identifier, height and weight attributes and a may_stand_on method, which determines whether an acrobat can stand on an another.
• Use Dynamic Programming to determine the number of the most people in the tower complies with the rules. Let you try the program with the following inputs. We have also given the number of the most possible people in the tower:
Input Max tower
cirkusz1.text 2
cirkusz2.text 3
cirkusz3.text 1
cirkusz4.text 100
cirkusz5.text 15
cirkusz6.text 37

11. Union of intervals

• Given $N$ closed intervals $[A_1, B_1], [A_2, B_2], \ldots [A_N, B_N]$, where $A_i$ and $B_i$ are natural numbers. We want to dermine the total length of the intervals, precisely the measure of the domain $\bigcup_{i = 1}^N [A_i, B_i]$.
• We provide an example program interval.py that reads the intervals from the file named in the command line argument. The file format is as follows:
1. The first line contains one natural number, the number of intervals $N$.
2. There are $A_i$ $B_i$ pairs in the next $N$ lines. These are the starting and the endpoint of the $i$-th interval, where $0 < A_i < B_i$.
3. The function read_intervals reads the intervals and return a list of Interval objects. The class Interval has two properties: start and end, these are the bounderies of the interval.
• Complete the code of the measure function, such that it calculates the total length of the intervals, that is the measure of the union of the intervals. Let's try to achieve the efficient algorithm of $O(N \log N)$ steps.
• Try the program on the following inputs. The efficient algorithm of $O(N \log N)$ steps runs on each of the following inputs in a few seconds. In addition to the inputs, we have given in the table the total length of the intervals.
Input Measure
interv1.text 9
interv2.text 596
interv3.text 6541
interv4.text 94581377
interv5.text 632741470

12. Binary search tree

• In this task a binary search tree data structure will be programmed. A part of the implementation of the search tree is given in the program bintree.py.
1. The binary tree is represented by the BinaryTree class. The root of the tree is contained by the root attribute. If the tree is empty, the value of this attribute is None, otherwise the root is an instance of the class TreeNode.
2. The nodes are the instances of the TreeNode class. The values of the left and right attributes are None, if no child is there, or the TreeNode instance representing the child node.
3. The methods of the BinaryTree class are insert, search_key, level, preorder_walk. They check if there is a root of the tree and then call on the appropriate recursion methods of the TreeNode class.
4. The common recursive part of the insert and search_key methods is the search_node method of the TreeNode class. This searches in the tree to find the key value received as a parameter and returns the node where the search stops. This is the node that contains the value we are looking for, or if the key value is not in the tree, the node which the key value node should be the child of.
5. The main program reads integers from the file given as a command line argument, and then inserts them into the binary tree. Then print out the values in the preorder order to the standard output and calculate the number of tree levels.
• Complete the file bintree.py with the missing parts!
1. Insert the given key into the tree in the insert method of the BinaryTree. You may use search_node method of TreeNode, which returns the node that either contains the value you are looking for or the value you are looking for is to be inserted as the direct child of the node. The use of this method is also illustrated by the search_key method of the BinaryTree class. Make sure that the insertion works on an empty binary tree or if a node is already contains the value you want to insert. In the latter case, the insertion is idempotent.
2. Print out the values of the tree with a recursion in the preorder order to the standard output in the preorder_walk method of TreeNode.
3. Using recursion, determine the number of levels of the tree in level method of TreeNode.
• Test the program with the binfa1.text file! Test some of your own testfiles!


text:
# Diff eq velocity problem

## Homework Statement

An object in free-fall has an acceleration (which is the rate of change in velocity with respect to time) of 32.2 feet per second2 downward plus air resistance. The air resistance is proportional to the velocity squared. If the initial velocity is 0 feet per second and the proportionality constant is .0095, write and solve a differential equation that would result the function describing the velocity at any given time.

## Homework Equations

Ordinary diff eq?

## The Attempt at a Solution

dv/dt = -32.2 + .0095v^2
Tried to solve for v

dextercioby
Homework Helper
Can you separate variables in your ODE ?

Ohh, yes, thank you! It's been awhile since I've done a diff eq... But, can I ask your opinion? Since it says the object is free falling, we should assuming it is still being acted upon by the force of gravity, right? So, is the acceleration given, 32.2 ft/s^2, the acceleration of the total force? Like this:

F(total)=F(air)-F(falling)=kv^2-mg
F(total)=ma=m*32.2

Or should I subsitute the 32.2 in for the gravity?

Thanks!

dextercioby
$$\frac{dv}{dt} = 32.20 - k v^2$$

format: plain


text:
• 论文 •

整数值时间序列模型单位根检验问题研究

• 出版日期:2016-08-15 发布日期:2016-08-11

Research on Unit Root Test for Integer-valued Time Series Models

Wang Zeyu et al.

• Online:2016-08-15 Published:2016-08-11

Abstract:

The unit root test research about the integer-valued time series is just getting started, compared with the non-integer-valued time series. In this paper, the Monte Carlo simulation would be ushered to check the DF statistic and the statistic in INAR (1) models with unit root process. Based on the research, DF statistic asymptotically conforms to the standard normal distribution, meanwhile the actual distribution of this statistic has been impacted by the sample size and the mean of the disturbance term in the finite sample. In addition, the DF statistic does not have the property of any level distortion. That is, the DF can well control the probability of type I error. Because of the data generation feature, the statistic’s probability of committing type I error is zero. Furthermore, the test powers of DF statistic and statistic are influenced by the sample size, autoregressive coefficient and the mean of the error term. In most cases, the test power of statistic is much better than the DF statistic.


text:
Converting from one base to another?
04-09-2016, 10:02 PM
Post: #1
 smp Senior Member Posts: 425 Joined: Jul 2015
Converting from one base to another?
Hello again all,

I have another newbie programming question.

As you may have seen, I developed an 8080 emulator that uses M1 as a single column array for the program memory. The 8080 instructions are stored as decimal numbers. I have been entering only very short test programs by hand to exercise my emulator so far.

I have the code from my system monitor in my vintage IMSAI system that allows a few activities, such as dump memory from one address to another, enter code byte by byte into memory, and goto a memory location and start executing.

I would like to enter this code into my M1 array for my emulator. I have the code as hexadecimal numbers. So, I tried to create a small program to allow me to enter hex bytes, and store them as decimal numbers. I figured I would be clever and simply change the Base to Hexadecimal for the hex entry, and then change the Base to Decimal to store the number into M1.

Here's the code:
Code:
 // LoadCode // // Load 8080 code into M1 // Input the first location in decimal, then increment from there // Input the 8080 code as hex bytes, convert to decimal and store // LOCAL loc,byte; // EXPORT LoadCode() BEGIN   byte:=0;   loc:=0;   INPUT(loc,"Starting Location","Start=","Enter the starting location in decimal",0);   WHILE (byte>=0) DO     byte:=M1(loc);     3->Base;  // set base to hexadecimal     INPUT(byte,"8080 Code","Byte=","Enter a byte as a hex number",0);     2->Base;  // set base to decimal     M1(loc):=byte;     loc:=loc+1;   END; END;

Unfortunately for me, this is not working. The program as written works just fine if I enter normal decimal numbers. However, if I enter 0A, 0B, 0C... it stores away 0. Also, if I try A, B, C, D, E, or F, I get unusual numbers instead of the expected 10, 11, 12, 13, 14, or 15.

This method of changing the Base is not working for me. Am I on the right track, or will I have to enter two-character strings and do the whole conversion myself?

smp
04-09-2016, 10:32 PM
Post: #2
 DrD Senior Member Posts: 1,132 Joined: Feb 2014
RE: Converting from one base to another?
Would chapter 28 of the user guide, particularly the B→R(#integerm) feature be of use for you? Integers prefixed by # and suffixed by o, h, d (octal, hex, decimal) in particular might be just what you need.

-Dale-
04-09-2016, 11:54 PM
Post: #3
 smp Senior Member Posts: 425 Joined: Jul 2015
RE: Converting from one base to another?
(04-09-2016 10:32 PM)DrD Wrote:  Would chapter 28 of the user guide, particularly the B→R(#integerm) feature be of use for you? Integers prefixed by # and suffixed by o, h, d (octal, hex, decimal) in particular might be just what you need.

-Dale-

Hi Dale,

Oh, no! I was hoping to be able to do the hex entry as C3 09 F3, rather than #C3h, #09h, #F3h. Well, too bad for me, I guess. Lots more typing than I hoped, unless I can figure out how to enter two character strings and do the conversion myself.

Thanks,
smp
04-10-2016, 02:38 AM
Post: #4
 Fortin Member Posts: 59 Joined: Jul 2015
RE: Converting from one base to another?
If 'byte' is a string, such as "C3", you could try something like: EXPR("#"+byte+"h")
04-10-2016, 04:33 AM
Post: #5
 informach Member Posts: 109 Joined: Jul 2015
RE: Converting from one base to another?
Hi!:

For convert, can use ... (see image).

Kind Regards.
informach.

Attached File(s) Thumbnail(s)

04-10-2016, 01:17 PM
Post: #6
 John Keith Senior Member Posts: 601 Joined: Dec 2013
RE: Converting from one base to another?
(04-09-2016 11:54 PM)smp Wrote:
(04-09-2016 10:32 PM)DrD Wrote:  Would chapter 28 of the user guide, particularly the B→R(#integerm) feature be of use for you? Integers prefixed by # and suffixed by o, h, d (octal, hex, decimal) in particular might be just what you need.

-Dale-

Hi Dale,

Oh, no! I was hoping to be able to do the hex entry as C3 09 F3, rather than #C3h, #09h, #F3h. Well, too bad for me, I guess. Lots more typing than I hoped, unless I can figure out how to enter two character strings and do the conversion myself.

Thanks,
smp

Why not a short program that puts the Prime in alpha mode then starts an input loop allowing you to enter the characters as you wish? The characters can then be converted to hex integers in the manner of Fortin's post above.

John
04-10-2016, 01:43 PM
Post: #7
 smp Senior Member Posts: 425 Joined: Jul 2015
RE: Converting from one base to another?
(04-10-2016 01:17 PM)John Keith Wrote:  Why not a short program that puts the Prime in alpha mode then starts an input loop allowing you to enter the characters as you wish? The characters can then be converted to hex integers in the manner of Fortin's post above.

John

Hi John,

Yes that is just what I was thinking. Doing alpha input, then converting those into numbers to be saved in M1. I have to keep thinking of how to get the computer to do the work, not me!

smp
04-10-2016, 02:08 PM
Post: #8
 Fortin Member Posts: 59 Joined: Jul 2015
RE: Converting from one base to another?
For testing in the short term, an input box that only accepts strings may also help:

INPUT(
{{byte,[2]}},
"8080 Code",
{"Byte="},
{"Enter a byte as a hex number"},
{""},
{""}
);
04-10-2016, 04:11 PM
Post: #9
 informach Member Posts: 109 Joined: Jul 2015
RE: Converting from one base to another?
Hi!:

This is a youtube videos, in Spanish Language, of the use conversion, base (b, d, h, o) ... https://www.youtube.com/playlist?list=PL...Q_K6ZRiLgP

Best Regards.
informach
04-10-2016, 06:24 PM
Post: #10
 smp Senior Member Posts: 425 Joined: Jul 2015
RE: Converting from one base to another?
Thanks very much to all who have offered their advice. I greatly appreciate your assistance.

Here is the code that I now have working:
Code:
// LoadCode // // Load 8080 code into M1 // Input the first location in decimal, then increment from there // Input the 8080 code as hex bytes, convert to decimal and store // LOCAL loc,byte,temp; // EXPORT LoadCode() BEGIN   byte:="";   loc:=0;   temp:=0;   INPUT(loc,"Starting Location","Start=","Enter the starting location in decimal",0);   WHILE (1) DO     INPUT(       {{byte,[2]}},       "8080 Code",       {"Byte="},       {"Enter a byte as a hex number"},       {""},       {""}       );     temp:=EXPR("#"+byte+"h");     M1(loc):=SETBASE(temp,3);     loc:=loc+1;   END; END;

Thanks again!

smp
04-12-2016, 04:44 AM
Post: #11
 cyrille de brébisson Senior Member Posts: 1,009 Joined: Dec 2013
RE: Converting from one base to another?
Hello,

The base editor is actually a quite OK convertor by itself...

in home, click on shift base twice and you enter the editor. Then you can click on edit to edit/enter the number that you want, in the base that you want, and see it in all the other bases...

you can perform shift operations directly there too (doing right and left swipes).

Cyrille

Although I work for the HP calculator group, the views and opinions I post here are my own. I do not speak for HP.
04-12-2016, 06:50 AM (This post was last modified: 04-12-2016 06:52 AM by leprechaun.)
Post: #12
 leprechaun Member Posts: 90 Joined: Mar 2015
RE: Converting from one base to another?
Take a look at RealCalc for android. That is a calculator for efficient base conversion.
I do agree that the prime's base menu is alright. But if I do serious work where base conversion is needed I do not want dialoge based apps or unnecessary keystrokes. I want to get the result asap.
Dealing with integers on the prime (like 4x) needs additional characters like # so more keys are required. You can't change that easily.

I tried some keybound user programs on softmenus to make unit conversion more comfortable for me, but sooner or later the device did not behave as expected and finally I stopped my work. rpn input is best if you do things like 'one keystroke' conversions....in cas there is no bases at all and, to be honest, I still don't really like the underlying philosophy of the prime. (or I cannot get used to it 100%)

I just don't want to be upset about the prime any more... :-( Too many other problems to be solved.
04-12-2016, 10:26 PM
Post: #13
 smp Senior Member Posts: 425 Joined: Jul 2015
RE: Converting from one base to another?
(04-12-2016 04:44 AM)cyrille de brébisson Wrote:  Hello,

The base editor is actually a quite OK convertor by itself...

Hi Cyrille,

I have about 1000 8080 instructions in hexadecimal that I want to load into M1 for my 8080 emulator. That is why I was trying to create a program. I simply want to enter a starting address location for M1, and then enter hex byte after hex byte, with the program converting the hex bytes into decimal numbers and storing them sequentially into M1. I don't think the Prime capability for doing the base conversion would be good for this. If I'm missing something, please let me know.

Thanks,
smp
04-12-2016, 11:07 PM
Post: #14
 DrD Senior Member Posts: 1,132 Joined: Feb 2014
RE: Converting from one base to another?
Would a subroutine for your application be useful? Perhaps, something like these:

Code:
 //  H2D(hex) // //  Hexadecimal to Decimal converter //  Input:  Hexadecimal as quoted string ("09aF") case doesn't matter //  Output: Decimal equivalent ==> (2479.00) EXPORT H2D(hex) BEGIN   D:=0; N:=SIZE(hex);   FOR I FROM 1 to N DO         D:=D+16^(N-I)*(INSTRING("0123456789ABCDEF", MID(UPPER(hex),I,1))-1);   END;   RETURN D;    END;

Code:
 //  D2H(dec) // //  Decimal to Hexadecimal converter //  INPUT:  Decimal value D2H(666) //  OUTPUT: Hexadecimal value ==> "29A" EXPORT D2H(dec) BEGIN   local digit,hex:="";   WHILE 0 < dec DO     digit:=dec MOD 16;     dec:= FLOOR(dec/16);     hex:= append(MID("0123456789ABCDEF",digit+1,1),hex);      END;   RETURN (IFTE(hex=="","0",hex)); END;
 « Next Oldest | Next Newest »

User(s) browsing this thread: 1 Guest(s)


text:
## anonymous one year ago State the coordinates of the y-intercept of the graph of -4x - 6y = 13. Your answer should be an ordered pair.

1. marihelenh

You need to get it into slope-intercept form which is y=mx+b. You would: 1) Add 4x to both sides. -6y=4x+13 2) Divide each side by -6 to get the equation into slope-intercept form. y=-2/3x-13/6 The y intercept is the b in y=mx+b. So, your y intercept is -13/6. Wherever the y intercept is, that means that x is equal to zero. So, you ordered pair is (x,y)=(0,-13/6) $(0,\frac{ -13 }{ 6 })$

2. UsukiDoll

to find the y-intercept, we have to set our x to 0 and then just solve for y... and that's already been done and it's the correct answer. Well done @marihelenh!


text:
# second order ordinary differential equation

A second order ordinary differential equation$F(x,\,y,\,\frac{dy}{dx},\,\frac{d^{2}y}{dx^{2}})=0$  can often be written in the form

 $\displaystyle\frac{d^{2}y}{dx^{2}}\;=\;f\left(x,\,y,\,\frac{dy}{dx}\right).$ (1)

By its general solution one means a function$x\mapsto y=y(x)$  which is at least on an interval twice differentiable and satisfies

 $y^{\prime\prime}(x)\;\equiv\;f(x,\,y(x),\,y^{\prime}(x)).$

By setting  $\frac{dy}{dx}:=z$,  one has  $\frac{d^{2}y}{dx^{2}}=\frac{dz}{dx}$,  and the equation (1) reads  $\frac{dz}{dx}=f(x,\,y,\,z)$.  It is easy to see that solving (1) is equivalent (http://planetmath.org/Equivalent3) with solving the system of simultaneous first order (http://planetmath.org/ODE) differential equations

 $\displaystyle\begin{cases}\frac{dy}{dx}=z,\\ \frac{dz}{dx}=f(x,\,y,\,z),\end{cases}$ (2)

the so-called normal system of (1).

The system (2) is a special case of the general normal system of second order, which has the form

 $\displaystyle\begin{cases}\frac{dy}{dx}=\varphi(x,\,y,\,z),\\ \frac{dz}{dx}=\psi(x,\,y,\,z),\end{cases}$ (3)

where $y$ and $z$ are unknown functions of the variable $x$.  The existence theorem of the solution

 $\displaystyle\begin{cases}y=y(x),\\ z=z(x)\end{cases}$ (4)

is as follows; cf. the Picard–Lindelöf theorem (http://planetmath.org/PicardsTheorem2).

Theorem.  If the functions $\varphi$ and $\psi$ are continuous and have continuous partial derivatives with respect to $y$ and $z$ in a neighbourhood of a point  $(x_{0},\,y_{0},\,z_{0})$,  then the normal system (3) has one and (as long as $|x\!-\!x_{0}|$ does not exceed a certain ) only one solution (4) which satisfies the initial conditions$y(x_{0})=y_{0},\;\,z(x_{0})=z_{0}$.  The functions (4) are continuously differentiable in a neighbourhood of $x_{0}$.

## References

• 1 E. Lindelöf: Differentiali- ja integralilasku III 1.  Mercatorin Kirjapaino Osakeyhtiö, Helsinki (1935).
Title second order ordinary differential equation SecondOrderOrdinaryDifferentialEquation 2013-03-22 18:35:39 2013-03-22 18:35:39 pahio (2872) pahio (2872) 5 pahio (2872) Topic msc 34A05 normal system normal system of second order


text:
If you are a programmer using linux or one of the Unix like operating systems such as Mac OS X or the BSD variants, you will be using the console or the shell on a daily basis to run commands.

As programmers, we typically prefer programming languages to run our calculations and to write code. However, one of the most popular (and usually the default) shells on *nix systems is a powerful programming language of its own. We are talking about the bash shell here.

In this post, the first of a series of posts on shell programming, we will start our exploration of the bash shell by taking a look at one of the most basic capabilities of a programming language - its arithmetic functions.

## Bash Shell Arithmetic

Bash supports all the basic arithmetic operators including the modulo operator and supporting an exponent operator in addition.

## Defining variables

A variable can be defined on the shell by assigning a value to it.

Examples:

$x = 10  $ y = 2

## Performing Arithmetic

Arithmetic operations can be performed using the following syntax.

(( <expression> ))

Let us look at some examples using the above defined variables.

$echo$(( x + y ))
12

### Subtraction

$echo$(( x - y ))
8

### Multiplication

$echo$(( x * y ))
20

### Division

$echo$(( x / y ))
5

### Exponentiation

$echo$(( x ** y ))
100

### Modulo

$echo$(( x % y ))
0

We can use numbers directly as well without needing variables.

$echo$(( 10 % 3 ))
1

## Variable Assignment

The result of an arithmetic operation can be assigned to another shell variable, just like any other shell variable.

$z=$(( x * y ))
echo $z 20  When performing such assignment, make sure there are no extra spaces after the = operator on the right. Otherwise you will get an error like the following, as the shell will interpret the value as a command. $z= $(( x * y)) 20: command not found  ## Complex Operations The shell can support complex arithmetic with the help of its built-in arithmetic operators and taking some help from additional programs. Let’s calculate the value of the following quadratic polynomial $$ax^2 + bx + c$$ for different values of the co-efficients, with varying values of x. ## Shell Functions The bash shell supports writing of functions. A function is defined using the function keyword. function hello { echo "hello world"; }  You can define the funcion inline in the shell. However a more common convention is to put the function inside a shell script typically ending with .sh extension. Once defined, you can call the function as if it were a command, on the shell. $ hello
hello world

Shell functions don’t accept arguments explicitly. Instead arguments are received by the $n notation. So $1 is the first argument, $2 the second and so on. $* is a wild-card for receiving all arguments as a single string. Arguments are seprated by spaces.

With the above background, let us write a shell function which will calcualte the value of our quadratic polynomial above. It will accept the value of a,b,c,d and x as its arguments in that order.

function qpolynomial()
{
# A polynomial function calcualting
# the value of a*x*x + b*x + c

# Pass arguments in the order a,b,c and x
a=$1;b=$2;c=$3;x=$4
echo "Polynomial is $a*x*x +$b*x + $c" local y=$((a*x*x + b*x + c))
echo "Value for {x=$x} is$y"
}

Note: The local keyword creates the variable y in the local scope

We can run this on the shell like a command, configuring it with different polynomials and values for x.

Calculate $$y=10x^2 + 5x + 2, x=1$$

$qpolynomial 10 5 2 1 Polynomial is 10*x*x + 5*x + 2 Value for {x=1} is 17  Calculate $$y=5x^2 - 8x + 20, x=2$$ $ qpolynomial 5 -8 20 2
Polynomial is 5*x*x + -8*x + 20
Value for {x=2} is 24

## Roots of a Quadratic Equation

Now that we’ve dipped our toes into the waters of the shell, let us plunge a bit more. We will develop a function which calculates the roots of a quadratic equation of the form,

$$ax^2 + bx + c = 0$$

Using the solution,

$$\frac{-b \pm \sqrt{b^2 - 4ac}}{2a}$$

The function will accept the co-efficients a,b and c as arguments.

Here is the code.

function quadratic_solver()
{

# Receive the co-efficients as 3 arguments
a=$1;b=$2;c=$3 echo "Solving the equation {${a}*x*x + ${b}*x +${c} = 0}"
# Calculate b*b - 4*a*c as 'y'
local y=$((b*b - 4*a*c)) # Calculate its square root using bc yroot=echo "scale=0; sqrt($y)" | bc
# Calculate root 1
local r1=$(((-1*b + yroot)/(2*a))) # Calculate root 2 local r2=$(((-1*b - yroot)/(2*a)))

echo "Roots are ($r1,$r2)"
}

Here we are using the shell program bc which is a precision calculator for calculating, $$\sqrt{b^2 - 4ac}$$

The reason is that the shell exponentiation operator cannot perform fractional exponents and we need a square-root here which is same as raising to 0.5.

## Running the Solver

Solving the equation $$x^2 -6x + 9 = 0$$

$quadratic_solver 1 -6 9 Solving the equation {1*x*x + -6*x + 9 = 0} Roots are (3, 3)  Solving the equation $$x^2 -7x + 12 = 0$$ $ quadratic_solver 1 -7 12
Solving the equation {1*x*x + -7*x + 12 = 0}
Roots are (4, 3)

Solving the equation $$x^2 -5x - 36 = 0$$

$quadratic_solver 1 -5 -36 Solving the equation {1*x*x + -5*x + -36 = 0} Roots are (9, -4)  ### Caveat and Further Steps Our simple shell program will work only with quadratic equations having integer solutions as shell cannot do fractional division. For example, the solution of $$3x^2 + 7x - 6 = 0$$ are $$x = (\frac{2}{3}, -3)$$ However our program calculates it as, $ quadratic_solver 3 7 -6
Solving the equation {3*x*x + 7*x + -6 = 0}
Roots are (0, -3)

This can be fixed easily by performing the division itself using bc or by printing the fraction as string expression in shell directly if we find the division does not yield a whole integer. This is left as an exercise to the reader.

Hope you enjoyed this post and learned something new about the bash shell. We will have more such posts in the future. If you liked this post, please share your comments after trying it. Have fun!

Note that name and e-mail are required for posting comments


text:
Plant Diversity ›› 2001, Vol. 23 ›› Issue (04): 1-3.

• Articles •

### Ecological Significance of Change of Leaf Form in Sabina vulgaris

HE Wei - Ming ZHANG Xin - Shi

1. Laboratory of Quantitative Vegetation Ecology, Institute of Botany, Chinese Academy of Sciences
• Online:2001-08-25 Published:2001-08-25

Abstract: Sabina vulgaris has two types of leaves (i.e. spine and scale leaves) . This study examined the differences in structure and function between spine and scale leaves, and hence their ecological significance of change of leaf form in the species, (l) The spine leaves had smaller cuticle thickness, epidermis cell size, mesophyll cell surface area, and vascular bundle size than the scale leaves. (2) Both tissue density and coefficient of water loss were higher in the spine leaves than in the scale leaves. (3) The spine leaves had higher net photosynthesis rate, transpiration rate, and the ratio of substomatal CO2 concentration to atmo-spheric CQz concentration than the scale leaves, but water use efficiency (WUE) was lower in the former than in the latter. Our results suggest that spine leaves had higher photosynthesis product accumulation and water loss than scale leaves, but both resistant - drought and resistant - radiation abilities and WUE were just opposite. Therefore, spine and scale leaves have different structure and function, which allows this species to adapt different environments.

Key words: Sabina vulgaris


text:
# GLAMbox¶

GLAMbox is a Python toolbox for investigating the association between gaze allocation and decision behaviour, and applying the Gaze-weighted Linear Accumulator Model (Thomas, Molter et al., 2019, full text available online).

See the GLAMbox paper for detailed background, model description and example applications.

## Installation¶

GLAMbox is written for Python 3.7 and requires a working Python environment running on your computer. We recommend to install the Anaconda Distribution (available for all major platforms). With the Python environment fully set up, the GLAMbox module can be installed from the command line using pip:

pip install glambox

This command also installs all of GLAMbox’s dependencies, which are listed in the requirements.txt file in the Github repository.

Tip

Using conda you can install glambox into a new environment, separate from your base environment:

1. Create a new environment named glambox: conda create -n glambox python=3.7
2. Activate it: conda activate glambox
3. Install the glambox module and its dependencies: pip install glambox

## Quickstart¶

Fitting the GLAM to a dataset can be done in just a few lines of code:

import glambox as gb
import pandas as pd

# load dataset (format must be GLAMbox compatible, of course)

# create the GLAM model object
model = gb.GLAM(data)

# build the PyMC3 model
model.make_model(kind='individual')

# perform MCMC sampling
model.fit()

# inspect parameter estimates
print(model.estimates)

# predict data using MAP estimates, save predictions
model.predict()
model.prediction.to_csv('prediction.csv')

A more detailed overview of the available functions can be found in the Basic Usage section and the API Reference.

## Application Examples¶

This documentation includes the three usage examples outlined in the GLAMbox paper with full code. The original Jupyter notebook files for these examples can be found in the examples folder in the Github repository. When downloaded and run with Jupyter (also included in the Anaconda Python distribution), the notebooks can be ran interactively.

### Example 1: Individual gaze biases¶

In this example, we demonstrate individual model fitting, model comparisons between model variants, and out-of-sample prediction.

### Example 2: Hierarchical parameter estimation¶

In the second example, we demonstrate how to setup a hierarchical model with multiple groups, and compare parameter estimates between groups.

### Example 3: Parameter Recovery¶

In the last example, we demonstrate how to perform a basic parameter recovery analyis for a given dataset, using GLAMbox.


text:
# Problem with a piece of calculation!

1. Nov 20, 2014

### ShayanJ

I'm reading Gourgoulhon's Special Relativity in general frames. In chapter 11, which is about the principle of least action, he constructs the relativistic version of this principle but I have problem with one part of it.
At first, he introduces Lagrangian and then from the fact that the action should be independent of the parametrization of the world line, concludes that the Lagrangian should be a positive homogeneous function of degree 1 w.r.t. the components of 4-velocity. So, using Euler's theorem for homogeneous functions, he writes:
$\dot x^\alpha \frac{\partial L}{\partial \dot x^\alpha}=L$.
After this, he derives the Euler-Lagrange equations $\frac{\partial L}{\partial x^\alpha}-\frac{d}{d \lambda}\frac{\partial L}{\partial \dot x ^\alpha}=0$.
Then, in a remark, he says that the fact that we have four Euler-Lagrange equations in the Relativistic case, which is one more than in the Newtonian case, doesn't mean that an extra degree of freedom is added to the system because the four equations aren't independent. I don't have a problem with this statement but the calculations he does afterwards(which are off-shell) doesn't seem clear to me and I can't reconstruct them!
$\dot x ^\alpha (\frac{\partial L}{\partial x^\alpha}-\frac{d}{d \lambda}\frac{\partial L}{\partial \dot x ^\alpha})= \dot x^\alpha \frac{\partial L}{\partial x^\alpha}-\frac{d}{d\lambda}(\dot x^\alpha \frac{\partial L}{\partial \dot x^\alpha})+\frac{d \dot x ^\alpha}{d \lambda}\frac{\partial L}{\partial \dot x^\alpha}=\frac{dL}{d \lambda}-\frac{d}{d \lambda}(\dot x^\alpha \frac{\partial L}{\partial \dot x^\alpha})$
I have problem with the 2nd equality. How is it done?
Thanks

Last edited: Nov 20, 2014
2. Nov 20, 2014

### ChrisVer

$\dot{x}^a \frac{\partial L}{\partial x^a}= \dot{x}^a \frac{d}{d \lambda} \frac{\partial L}{\partial \dot{x}^a}$ (E-L equat)

$\frac{d \dot{x}^a}{d\lambda} \frac{\partial L}{\partial \dot{x}^a}+ \dot{x}^a \frac{d}{d \lambda} \frac{\partial L}{\partial \dot{x}^a}= \frac{d}{d \lambda} (\dot{x}^a \frac{\partial L}{\partial \dot{x}^a})$ the 1st and 3rd terms in your equation after replacing the 1st term with the E-L equation result... it's a total derivative of lambda...

$\frac{d}{d \lambda} (\dot{x}^a \frac{\partial L}{\partial \dot{x}^a})= \frac{d}{d\lambda} (L)$ (using your first equation for L)

Then there you got the result

3. Nov 20, 2014

### ShayanJ

Yeah, that works but as I said his calculations are of-shell. He says: "To make this explicit, let us evaluate the following expression, without assuming that (11.17) holds " where 11.17 are the E-L equations!

4. Nov 20, 2014

### ChrisVer

Maybe then you have to look what the total derivative of L wrt to lambda is...assuming that it has no explicit dependence on it,...

5. Nov 20, 2014

### ShayanJ

Oh my god...Its just I was being too careless. Of course 1st and 3rd terms add up to the L's total derivative. Thanks man!


text:
# Shrinking very large barcodes

My apologies is this is not the right place for this question, please advise if it needs to be moved or deleted.

So my city has an art installation of some very tall Dr.Suess style flowers.

These flowers have barcodes that runs down the length of the stalk and I am looking for ideas on how to capture or identify the pattern to then begin working in decoding them.

I have attached a picture showing the flowers and the barcodes. It has been confirmed by the creators that the patterns are indeed barcodes.

• Has a correct answer been given? If so, please don't forget to $\color{green}{\checkmark \small\text{Accept}}$ it :) – Rubio Feb 18 at 10:30
• @Rubio How did you do the green font? – Tomáš Zato Feb 18 at 11:40
• No clue about the magix of that stuff but given that it doesn't render in the app: $\color{green}{...}$ – geisterfurz007 Feb 18 at 12:19
• @geisterfurz007 MathJax magix! – Thomas Ayoub Feb 18 at 13:22

Not sure if this is really on topic, since it's more about image manipulation than the puzzle itself, but I'll answer anyway (and keep it on topic by solving the puzzle at the same time).

You can convert them with photo manipulation software as follows:

1) Isolate a barcode:

2) Warp to stretch the stripes:

3) Convert to black & white (and rotate):

Using an online scanner, you can then decode those images. From left to right in your photo (one word per flower), you get:

Corson
sonic
energy
science
bloom

After having got the above list, I see that those words seem to fit neatly with the art installation itself (found via reverse image search):

Which is titled Sonic Bloom, by Dan Corson, and is thematically tied to energy and science.

• I'm somewhat partial to Code 39 myself, since it merely uses two widths of bar and two widths of space, and is easier to decode by eyeball. – supercat Feb 18 at 20:46


text:
Cultural Unity

A Chat with Yuel Bhatti, Local ABC4All / Pakistan Co-Founder that can be with ANYONE in the world!

 Topics:

 Global Humanitarian Relief Working together to bring GHR to the World!

A message to all members of Global Humanitarian Relief

From Burton Danet/Yuel Bhatti
ABC4All / Local ABC4All / Pakistan
Home for Campaign for Global Humanitarian Relief (GHR)
http://ghrd.abc4all.net

Yuel Bhatti
TIG: http://profiles.tigweb.org/Billu
MOTW: http://abc4all.net/mentoryuelbhatti.htm
Co-Founder Local ABC4All / Pakistan:  http://abc4all.net/localabc4all.html

http://ghrd.abc4all.net/articles/view/148892/?topic=46919

5:46 AM Yuel:
Hi I know you are busy but just want to say thanks for posting message
of UN S.G Ban Ki-Moon and recognition by URI / Pat /  you.
me: Always ready to hear from you and and to talk to you.

Are you safe given all the difficult events in Lahore?
5:47 AM We are at heart doing what is needed and work together.

good collaboration of promotion of peace by ABC4All as well

me: She is learning, too, just like the rest of us.

5:48 AM Around 08/01/10, we are launching the major Campaign for Global Humanitarian Relief (GHR) and if you will help with your
referrals that will be outstanding.

me: The attorney volunteer who is spearheading the campaign is recovering from an illness
doctors cannot cure since drinking Plasma Activated Water (PAW) http://kindrop.abc4all.net
He wants to remain anonymous.

Yuel: Yes of course.

me: We will respect his wish to remain anonymous

5:49 AM Yuel: OK
me : His idea is that we empower all NGOs/nonprofits to cooperate with The Foundation For
A Better Community For All (FABC) http://fabc.yolasite.com/ in a venture where a
donation could be US$0.99 (99 cents) or just under$1.00.

If 1 million to 1 billion people donate 99 cents each, we are going to be home free and

5:50 AM Yuel: Wonderful
me:
He is arranging for FABC to own the patents and control the technology
so it is in humanitarian hands and no corporation will hoard money and
give little, if anything to charity.

5:51 AM We will return 50% of all donations to a given nonprofit when their members donate to GHR.

100% of 50% with no expenses deducted.
This is his inspiration and he wants to remain anonymous...

But I can introduce you to him.
Yuel: It is my pleasure.

me: If we can help people understand that all that is needed is an IMMEDIATE donation of
$0.99, we will work together to bring RELIEF to the world. 5:53 AM and then every one of us encourages each person in our network to do the same, that is, tell everyone and ask that they, too, donate$0.99, and each tells all their people in their
network, etc., including teenagers and school children with permission
of their parents, etc. and spread this around all the schools of the
world, all the religious groups in the world, etc.

Yuel: Yes is so nice and with small donation we can change the world. Can we
put on Change.org
me: Then we will be able to get the scientists housed and start creating
preparing reactors we will bring to where the reactors where they are
needed the most (first Haiti).

5:54 AM We have identified 2 cooperating parties who have 6 acres and 26 acres of land in Haiti where we will do a demo.
Glossary

Citation

Danet, B. (2010). A Chat with Yuel Bhatti, Local ABC4All / Pakistan Co-Founder that can be with ANYONE in the world!. Retrieved from http://kindrop.abc4all.net/view/blog/51cbecb27896bb431f68d4ed


text:
# Torque required to rotate an object at an angle

#### jhogue74

I am trying to work out the torque required to rotate a platform, initially declined at an angle. See attached hand sketch.
My situation is
- I have a platform initially at a declined angle, say at 0 degrees.
- I have a load at the end of the platform at 0 degrees
- I want to be able to rotate the platform and load 180 degrees from its initial position
- I am ignoring the platform self weight at the moment for simplicity

My thoughts are that the torque required is related to the amount of work required to lift the load F from point 1 to point 2, for now ignoring efficiencies of components etc. The final torque required will be based on the slew ring I choose to allow the circular movement.

Could anyone give me their thoughts on my situation. Trying to work my way through what loads/forces are to be considered and then resolving this back to a torque at the drive motor.

Thanks,

Jason

#### Attachments

• 37.1 KB Views: 86
Related Mechanical Engineering News on Phys.org

#### BvU

Homework Helper
Hello jhogue, $\quad$ $\quad$ !

torque in your scenario depends on how far the platform has rotated: it's 0 at 0 and 180 degrees and maximum at 90.

At that point you have an opposing torque $\ F\sin(85) \$ times the distance between load and axis.

I don't understand what a slew ring is or what it is supposed to do.

### Want to reply to this thread?

"Torque required to rotate an object at an angle"

### Physics Forums Values

We Value Quality
• Topics based on mainstream science
• Proper English grammar and spelling
We Value Civility
• Positive and compassionate attitudes
• Patience while debating
We Value Productivity
• Disciplined to remain on-topic
• Recognition of own weaknesses
• Solo and co-op problem solving


text:
# Solution of the Laplace Equation Using Coordinates Fitted to the Boundary Conditions

Requires a Wolfram Notebook System

Interact on desktop, mobile and cloud with the free Wolfram CDF Player or other Wolfram Language products.

Requires a Wolfram Notebook System

Edit on desktop, mobile and cloud with any Wolfram Language product.

This Demonstration solves the 2D steady-state heat conduction equation in a physical domain that does not conform to an orthogonal coordinate system. The physical domain is mapped onto a unit square using boundary-fitted coordinates. The transformed heat conduction equation in the computational domain is then solved using a central-difference finite-difference scheme. You can vary the number of grid points in the and directions of the computational domain as well as the Biot number parameter for heat transfer from the upper surface. The resulting isotherms are shown for both the physical and computational domains. The mapping of the grid points from the - computational domain to the - points in the physical domain is also shown.

Contributed by: Brian G. Higgins and Housam Binous  (October 2011)
Open content licensed under CC BY-NC-SA

## Details

Background

Undergraduate students are often exposed to various numerical methods for solving partial differential equations. For example, in a sophomore engineering heat-transfer course, the finite-difference method is introduced to solve steady-state heat conduction problems, in which the computational domain conforms to one of the traditional orthogonal coordinate systems (i.e., rectangular, cylindrical, or spherical). In this Demonstration, we consider a 2D steady-state heat conduction problem in a physical domain based on a nonstandard orthogonal coordinate system:

We show how this problem can be solved using a traditional central-difference method with boundary-fitted coordinates.

The steady-state temperature distribution in the cavity is described by the following boundary-value problem (BVP) with four boundary conditions (BC1–BC4):

,

BC1: for and ,

BC2: for and ,

BC3: for and ,

BC4: for and .

The upper boundary is specified as an arc of a circle, given by , and has unit normal , .

Dimensionless Variables

It is desirable to make the BVP dimensionless before attempting to solve it numerically. We introduce the following dimensionless variables:

, , and .

The dimensionless form of the equations becomes:

,

BC1: for and ,

BC2: for and ,

BC3: for and ,

BC4: for and ,

where is the Biot number.

The interface equation becomes:

.

For notational convenience, we suppress the hat () notation and use the above formulation in what follows.

Boundary-Fitted Coordinates

The physical domain is defined by the coordinates and .

: , .

We now suppose that we have the following mapping that maps the physical domain into a unit square in the computational domain:

, ,

: , .

Thus the dimensionless temperature profile in the computational domain is defined by the mapping: . We can use the chain rule for differentiation to determine the explicit form for the Laplacian in the transformed coordinates (ξ, η).

Thus

.

Clearly when s uniform (flat) then and we get:

, which is the Laplacian in rectangular coordinates with scaled with the height .

Finite Difference Solution

To generate our finite-difference formula, we use the following grid template:

and use central differences for all derivatives. Thus at node , we have the following approximation for the function :

,

,

,

.

Thus the discretized version of the Laplacian of ψ at an interior node 0 is given by

,

where the coefficients are given by

, ,

, .

Once the grid is specified, then the coefficients can be computed at the given node, for a given .

Boundary Conditions at the Interface

At the interface, the heat flux is given by

at .

We will use a central-difference scheme for this BC:

and ,

which introduces a fictitious node that lies outside the domain:

,

where

and .

Solving for the fictitious node, we get

.

References

[1] C. Chen and J. M. Floryan, "Numerical Simulation of Nonisothermal Capillary Interfaces," Journal of Computational Physics, 111(1), 1994 pp. 183–193. doi:10.1006/jcph.1994.1053.

[2] M. Hamed and J. M. Floryan, "Marangoni Convection. Part 1. A Cavity with Differentially Heated Sidewalls," Journal of Fluid Mechanics, 405, 2000 pp. 79–110. journals.cambridge.org/abstract_S002211209900734X.

## Permanent Citation

Brian G. Higgins and Housam Binous

 Feedback (field required) Email (field required) Name Occupation Organization Note: Your message & contact information may be shared with the author of any specific Demonstration for which you give feedback. Send


text:
# Optimal Newton-type methods for nonconvex smooth optimization

2 February 2012
14:00
Dr Coralia Cartis
Abstract
We show that the steepest-descent and Newton's methods for unconstrained nonconvex optimization under standard assumptions may both require a number of iterations and function evaluations arbitrarily close to the steepest-descent's global worst-case complexity bound. This implies that the latter upper bound is essentially tight for steepest descent and that Newton's method may be as slow as the steepest-descent method in the worst case. Then the cubic regularization of Newton's method (Griewank (1981), Nesterov & Polyak (2006)) is considered and extended to large-scale problems, while preserving the same order of its improved worst-case complexity (by comparison to that of steepest-descent); this improved worst-case bound is also shown to be tight. We further show that the cubic regularization approach is, in fact, optimal from a worst-case complexity point of view amongst a wide class of second-order methods. The worst-case problem-evaluation complexity of constrained optimization will also be discussed. This is joint work with Nick Gould (Rutherford Appleton Laboratory, UK) and Philippe Toint (University of Namur, Belgium).
• Computational Mathematics and Applications Seminar


text:
# Monthly Archives: December 2013

brewing

## A Hoppy Red Ale

To my mind, a hoppy red ale is the quintessential contemporary American beer. This style is influenced by a variety of European styles: the slightly sweet maltiness and caramel hue of a German lager; the hop-forward bitterness and floral bouquet of an English IPA; the clean and subtle yeast character that American pale ales inherited from their British predecessors. Combining these features with the punchy zest of strong American hop varieties gives an entirely different breed of beer that is distinctly American.

My first experience with such a beer was Rogue’s Saint Rogue Red, which is a relatively mild incarnation of the style. Lately, one of my favorites is Green Flash’s Hop Head Red, which has a decidedly more assertive flavor profile. Bear Republic’s Hop Rod Rye incorporates flaked rye to the malt bill for a delightful twist on the style. Having developed a strong taste for the hoppy red ale, I figured it was time to try my hand at making my own variation. Here is the recipe I devised for a 5 gallon batch:

Grain

• 8 lb pale malt (American 2 row)
• 5 lb Munich malt (light)
• 1 lb flaked rye
• 8 oz crystal 60L
• 2 oz black patent

Hops

• 1.5 oz Chinook (60 min)
• 1.5 oz Centennial (20 min)
• 2 oz Cascade (5 min)
• 2 oz Centennial (dry hop)

Yeast

Mash 2 temperature infusion

• Mash in 145 F for 30 min
• Raise to 154 F for 30 min
• Sparge at 165 F

Fermentation

• 2 weeks in the primary at 60 – 65 degrees
• 2 weeks in the secondary with dry hop

Notes For some reason, my mash in was significantly cooler than expected, so I had to add extra boiling water to hit my target temperature of 145 F. As a result, I ended up adding more hot water, giving about 8 gallons of sweet wort. I let the boil go for about 3 hours to boil off the extra water. I anticipate that this will result in a slightly more intense maltiness and sweetness than otherwise, but there are enough hops in it that it should still be well balanced. I ended up with just over 5 gallons of wort with an initial gravity of around 1.065.

Update I just racked the beer to the secondary fermentor and added the dry hop. The beer had a gravity of 1.011, which corresponds to an abv of around 7%. I snuck a taste, and everything is good so far!

teaching

## Math 32A/H Final Review Materials

I have started compiling some review materials for math 32A and 32AH for this quarter. They consist of

I will post solutions to the exercises before the review session on Thursday. As always, let me know in the comments below if anything is unclear or incorrect.

Update I have posted the solutions to the practice problems. Also, a student pointed out a typo in statement of the final problem in the review. Spherical coordinates should be given by
$$x = \rho \cos \theta \sin \varphi, \quad y = \rho \sin \theta \sin \varphi, \quad z = \rho \cos \varphi.$$
These changes have been made in the version of the problems and solutions online.

Update 2 There was a mistake in the solution of problem 10 involving curvature. This has (hopefully) been fixed.


text:
## College Algebra 7th Edition

The first five terms are: $a_1 = -4$ $a_2 = 2$ $a_3 = 8$ $a_4 = 14$ $a_5 = 20$ The sequence is arithmetic with $d=6$. The $n^{th}$ term $a_n$ is given by the formula: $a_n=-4 + 6(n-1)$
Find the first five terms by substituting 1, 2, 3, 4 and 5 to $n$ in the given formula. $a_1 = 6(1) - 10 = 6-10 = -4$ $a_2 = 6(2)-10 = 12-10 = 2$ $a_3 = 6(3)-10 = 18-10 =8$ $a_4 = 6(4)-10 = 24-10 = 14$ $a_5 = 6(5)-10=30-10 = 20$ A sequence is arithmetic if there exists common difference among consecutive terms. Note the consecutive terms increase by $6$. Thus, the sequence is arithmetic with $d=6$. The $n^{th}$ term $a_n$ of the sequence, whose $a=-4$ and $d=6$, is given by the formula: $a_n=-4 + 6(n-1)$


text:
Evaluate limit without evaluating integral

Is it possible to evaluate the limit $$\lim\limits_{\epsilon \to + 0} \epsilon^2\int\limits_0^\epsilon \frac{r^{d-1} \, dr}{(r^2+\epsilon^2)^{\frac{d+2}{2}}}, \quad d > 2,$$ without evaluating the integral for each $\epsilon > 0$? Estimating the numerator in the integral by $r(r^2+\epsilon^2)^{\frac{d-2}{2}}$ I can obtain an upper estimate $1/4$. The L'Hopital rule doesn't help.

I would start with $$\lim\limits_{\epsilon \to + 0} \epsilon^2\int\limits_0^\epsilon \frac{r^{d-1} \, dr}{(r^2+\epsilon^2)^{\frac{d+2}{2}}} =\lim\limits_{\epsilon \to + 0} \int\limits_0^1 \frac{u^{d-1} \, du}{(u^2+1)^{\frac{d+2}{2}}}.$$ Then, clearly, we need to evaluate the last expression, which is not that evident.


text:
# B Bohmian Spacetime?

1. Feb 27, 2017

### mieral

If the world is really described by say Bohmian Mechanics or Objective Collapse. does it mean Spacetime is also objective or a substance in some way or absolutely no relationship between the quantum mechanism and spacetime? But then if no connection.. how can one have a wave function that is actual versus a spacetime that is just computations.. how do they couple to each other?

2. Feb 27, 2017

### Demystifier

It depends on quantum gravity, and we do not know what is the correct theory of quantum gravity. In the Bohmian interpretation of Wheeler-DeWitt equation (which is a candidate for quantum gravity), spacetime metric is objective.

3. Feb 27, 2017

### Daisyroots

May I ask what is intended by 'objective'? As I have it - and please correct me - matter equates to energy, which in turn equates to heat/movement, these latter indivisible. Is anybody able to say what it is that might get warm or move?

Last edited: Feb 27, 2017
4. Feb 27, 2017

### mieral

if spacetime metric is objective.. how do you deal with the diffeomorphism invariance.. or the Einstein hole argument of this realistic spacetime?

5. Feb 28, 2017

### Demystifier

Let me be more precise. First, only the space metric is objective. In this Bohmian theory of quantum gravity there is a preferred foliation of spacetime into space and time. Second, the space metric $g_{ij}$ is objective in the same sense in which metric in classical GR is objective. There is still a space diffeomorphism invariance.

6. Feb 28, 2017

### Daisyroots

Any takers for #3?

7. Feb 28, 2017

### A. Neumaier

hmmm, it is only a grossly simplified version of quantum gravity....

8. Feb 28, 2017

### Demystifier

Why do you think so?

9. Feb 28, 2017

### Demystifier

That's quite elementary and not really related to Bohmian mechanics and quantum gravity. So only a short answer: Matter is not equal to energy, energy is not equal to heat/movement, and being indivisible does not mean that it is not objective.

10. Feb 28, 2017

### A. Neumaier

Because it is not a relativistic field theory but an equation for the 3-dimensional spatial metric. Moreover, the quantum version is ill-defined.

11. Feb 28, 2017

### martinbn

That is unusual. In a quantum theory of gravity, where the quantum is based on Bohmian mechanics, there are preferred space and time. But in the classical limit there aren't. Some unification is achieved in the classical limit, isn't that the opposite of what usually happens? By the way what selects the preferred time coordinate?

12. Feb 28, 2017

### Daisyroots

Thanks. If we can say what matter is not, ie. as you say it is not (simply anyway) energy, can we say what it is?

13. Feb 28, 2017

### Demystifier

This is not unusual, especially if you read condensed-matter physics literature. In condensed matter, the "fundamental" theory is non-relativistic quantum mechanics of atoms. From this one can get various quantum and classical effective field theories, which are valid at distances much larger than the size of atom. For instance, the wave equation of sound is Lorentz invariant (with the velocity of sound instead of velocity of light).

In condensed matter, it is the frame in which the atoms are at rest. In Bohmian quantum gravity - nobody knows.

14. Feb 28, 2017

### Demystifier

There are several definitions of energy, one of them is eigenvalue of the Hamiltonian.

15. Feb 28, 2017

### Demystifier

It is ill-defined due to UV divergences, but it certainly doesn't make it "simplified". Concerning the claim that it is not relativistic, this is like claiming that quantum electrodynamics in Coulomb gauge is not relativistic because it is a theory for the 3-dimensional spatial vector potential.

16. Feb 28, 2017

### A. Neumaier

But the wave equation of sound corresponds to a classical effective field theory. Where is the quantum example?
The simplified referred to the cases (minisuperspaces) where one can make proper sense out of the equations.
No. In QED one can (and has to!) prove covariance of the quantum version in Coulomb gauge by exhibiting (in perturbation theory) an explicit set of operators generating the Poincare group. To do the same for the Wheeler-deWitt equations would require to exhibit (in perturbation theory) an explicit set of local operators generating the local Lorentz groups, and another set of operators generating the diffeomorphism group. I don't think anyone has done this.

17. Feb 28, 2017

### Demystifier

It's quantization gives phonons.

18. Feb 28, 2017

### Demystifier

The classical limit of WdW equation is Hamilton-Jacobi equation for GR, which is certainly consistent with standard formulation of GR. But you are probably right that in the quantum case there are additional problems. Loop quantum gravity (LQG) is a canonical quantization of gravity which is supposed to eliminate those problems, but for LQG it is not clear that it gives the right classical limit. Unfortunately, we do not longer have Marcus with us, who could say more.

19. Feb 28, 2017

### A. Neumaier

But the dispersion relation of phonons is not covariant.

20. Feb 28, 2017

### Demystifier

It is in the long distance limit (small $k$).


text:
# Matrix Proof

• Jan 23rd 2013, 08:19 AM
guybrush92
Matrix Proof
Hey, I've been trying to prove that the inverse of the transpose of a matrix, is equal to the transpose of the inverse of a matrix, i.e.

$(A^T)^(-1)=(A^(-1))^T$

(also, some help on how to use TEX would be useful...)
• Jan 23rd 2013, 08:40 AM
BobP
Re: Matrix Proof
Are you allowed to assume that $(AB)^{T}=B^{T}A^{T}$ ?

If so, take the transpose of $AA^{-1}=I$ and postmultiply by $(A^{T})^{-1}.$

For the LaTex input, use the Go Advanced option and 'press' the $\Sigma$ button and between the two [Tex] brackets type the line in as

(A^{T})^{(-1)}=(A^{(-1)})^{T}.

The ^ symbol translates as 'to the power of', and the power is then closed within the curley brackets.
• Jan 23rd 2013, 09:54 AM
Deveno
Re: Matrix Proof
by definition an inverse for an nxn matrix A is an nxn matrix B such that AB = I.

and....

$A^T(A^{-1})^T = (A^{-1}A)^T = I^T = I$


text:
### Author Topic: Solution of Question 3  (Read 2175 times)

#### Chaojie Li

• Full Member
• Posts: 21
• Karma: 0
##### Solution of Question 3
« on: March 19, 2015, 09:08:28 PM »
1.  Using the proof of maximum principle prove the maximum principle for
subharmonic functions and minimum principle for superharmonic
functions.

2.  Show that minimum principle for subharmonic functions and maximum
principle for superharmonic functions do not hold (*Hint*: construct
counterexamples with $f=f(r)$).

3.  Prove that if $u,v,w$ are respectively harmonic, subharmonic and
superharmonic functions in the bounded domain $\Omega$,
coinciding on its boundary ($u|_\Sigma=v|_\Sigma=w|_\Sigma$)
then in $w\ge u \ge v$ in $\Omega$.

SO i just post what i write on paper
« Last Edit: March 20, 2015, 08:08:11 AM by Victor Ivrii »

#### Chaojie Li

• Full Member
• Posts: 21
• Karma: 0
##### Re: Solution of Question 3
« Reply #1 on: March 19, 2015, 09:10:17 PM »
This is my solution of Q3 b

#### Victor Ivrii

c Is easy: if $u$ is subharmonic (or superharmonic)  and $v$ is harmonic with the same boundary value $(u-v)|_\Sigma =0$ then $u-v$ is subharmonic (or superharmonic) and then by maximum (or minimum) principle $(u-v)\le \max _\Sigma (u-v) =0$ (or $(u-v)\ge \min _\Sigma (u-v) =0$ and thus $u\le v$ ($u\ge v$ respectively)


text:
0 like 0 dislike
19 views
For the function $f(x) = 2x^5-5x$, determine the gradient of the tangent to the curve at the point $x = 2$.
| 19 views

1 like 0 dislike
dy/dx =10x^4- 5 = 155

by Diamond (85.5k points)
selected by
0 like 0 dislike
f(x) = 2x^5 - 5x  where x=2

f( 2) = 2(2)^5 - 5(2) = 54

the gradient to the tangent is m = 54
by Wooden (1.5k points)

0 like 0 dislike


text:
# Andrea Medini

Postdoctoral Researcher
Kurt Gödel Research Center
University of Vienna
Währinger Straße 25
1090 Vienna, Austria
e-mail: andrea.medini@univie.ac.at
Research interests: general topology, set theory

Curriculum vitae

The topology of ultrafilters as subspaces of the Cantor set and other topics, Ph.D. thesis, written under the supervision of K. Kunen

## Publications

Every zero-dimensional homogeneous space is strongly homogeneous under determinacy, with R. Carroy and S. Müller (submitted)

On Borel semifilters, Topology Proc. 53 (2019), 97-122

Infinite powers and Cohen reals, with J. van Mill and L. Zdomskyy, Canad. Math. Bull. 61:4 (2018), 812-821

Productively Lindelöf spaces of countable tightness, with L. Zdomskyy, Houston J. Math. 43:4 (2017), 1263-1272

Non-meager free sets and independent families, with D. Repovš and L. Zdomskyy, Proc. Am. Math. Soc. 145:9 (2017), 4061-4073

Every filter is homeomorphic to its square, with L. Zdomskyy, Bull. Pol. Acad. Sci., Math. 64:1 (2016), 63-67

A homogeneous space whose complement is rigid, with J. van Mill and L. Zdomskyy, Israel J. Math. 214:2 (2016), 583-595

Distinguishing perfect set properties in separable metrizable spaces, J. Symb. Log. 81:1 (2016), 166-180

Seven characterizations of non-meager P-filters, with K. Kunen and L. Zdomskyy, Fund. Math. 231:2 (2015), 189-208

Countable dense homogeneity in powers of zero-dimensional definable spaces, Canad. Math. Bull. 58:2 (2015), 334-349

Between Polish and completely Baire, with L. Zdomskyy, Arch. for Math. Logic 54:1-2 (2015), 231-245

Products and countable dense homogeneity, Topology Proc. 46 (2015), 135-143

The topology of ultrafilters as subspaces of $2^\omega$, with D. Milovich, Topology Appl. 159:5 (2012), 1318-1333

Products and h-homogeneity, Topology Appl. 158:18 (2011), 2520-2527

A non-CLP-compact product space whose finite subproducts are CLP-compact, Topology Appl. 157:18 (2010), 2829-2833

## Selected talks

Homogeneous spaces and Wadge theory (semi-plenary talk), given at the 33rd Summer Conference on Topology and its Applications, July 17-20, 2018, Bowling Green, Kentucky

Almost every homogeneous Borel space is a semifilter, given at the 31th Summer Conference on Topology and its Applications, August 2-5, 2016, Leicester, United Kingdom

Topological homogeneity and infinite powers (semi-plenary talk), given at the 30th Summer Conference on Topology and its Applications, June 23-26, 2015, Galway, Ireland

Dropping Polishness, given at Sets and Computations, session on Set Theory, March 30-April 10, 2015, Institute for Mathematical Sciences, National University of Singapore

Seven characterizations of non-meager P-filters, given at the 48th Spring Topology and Dynamics Conference, March 13-15, 2014, University of Richmond

Countable dense homogeneity and set theory, given at the AMS Sectional Meeting, session on Set Theory and Boolean Algebras, April 13-14, 2013, University of Colorado, Boulder

Clopen sets in products: CLP-compactness and h-homogeneity, given at Auburn University, March 2, 2012

The topology of ultrafilters as subspaces of $2^\omega$, given at the AMS Sectional Meeting, session on Set Theory, September 10-11, 2011, Cornell University

Products and h-homogeneity, given at the International Conference on Topology and its Applications, June 26-30, 2010, Nafpaktos, Greece

Van Douwen's problem on the cellularity of compact homogeneous spaces
, specialty exam, given at the Southern Wisconsin Logic Colloquium

Elementary submodels of the universe, a very basic introduction, given at the late Graduate Participation Seminar in Logic