text:
# 05 Best response polytopes¶

## Corresponding chapters¶

Duration: 100 minutes

## Objectives¶

• Define the best response polytopes (using both definitions: convex hull and halfspaces).
• Labelling of vertices
• Equivalence between equilibrium and fully labeled pair
• Vertex enumeration

## Notes¶

### Defining best response polytopes¶

Discuss what an average is. Place this in the context of the line between two points. Weighted averages of two points are just a line. So an average is just a probability distribution. Expand this notion to the average over two points. How would you take the weighted average between three points $$x, y, z$$:

$\lambda_1 x + \lambda_2 y + \lambda_3 z$

This corresponds to something like:

Explain how another definition for that space would be to draw inequalities on our variables. Give definition of best response polytopes for a game. Illustrate this with the battle of the sexes game (scaled):

$\begin{split}A = \begin{pmatrix} 3 & 1\\ 0 & 2\\ \end{pmatrix} \qquad B = \begin{pmatrix} 2 & 1\\ 0 & 3\\ \end{pmatrix}\end{split}$

Go over the definition of the best response polytopes.

The row best response polytope is given by:

$\mathcal{P} = \left\{x\in\mathbb{R}^{m}\;|\;x\geq 0; xB\leq 1\right\}$

This corresponds to the following inequalities:

• $$x_1\geq 0$$
• $$x_2\geq 0$$
• $$2x_1\leq 1$$
• $$x_1+3x_2\leq 1$$

From this we can identify the vertices:

• $$(x_1, x_2)=(0,0)$$
• $$(x_1, x_2)=(1/2,0)$$
• $$(x_1, x_2)=(0,1/3)$$
• $$(x_1, x_2)=(1/2,1/6)$$

This can be confirmed using nashpy:

>>> import numpy as np
>>> import nashpy as nash
>>> B = np.array([[2, 1], [0, 3]])
>>> halfspaces = nash.polytope.build_halfspaces(B.transpose())
>>> for v, l in nash.polytope.non_trivial_vertices(halfspaces):
...     print(v)
[0.5 0. ]
[0.         0.333...]
[0.5        0.166...]

The column best response polytope is given by:

$\mathcal{Q} = \left\{y\in\mathbb{R}^{m}\;|\;Ay\leq 1; y\geq 0\right\}$

This corresponds to the following inequalities:

• $$3y_1+y_2\leq 1$$
• $$2y_2\leq 1$$
• $$y_1\geq 0$$
• $$y_2\geq 0$$

From this we can identify the vertices:

• $$(y_1, y_2)=(0,0)$$
• $$(y_1, y_2)=(1/3,0)$$
• $$(y_1, y_2)=(0,1/2)$$
• $$(y_1, y_2)=(1/6,1/2)$$

Confirmed:

>>> import numpy as np
>>> A = np.array([[3, 1], [0, 2]])
>>> halfspaces = nash.polytope.build_halfspaces(A)
>>> for v, l in nash.polytope.non_trivial_vertices(halfspaces):
...     print(v)
[0.333... 0.        ]
[0.  0.5]
[0.1666... 0.5       ]

### Pair activity¶

Ask everyone to draw these two polytopes.

Now describe how we label the vertices: using the same ordering as the inequalities (starting at 0), a vertex has the label corresponding to that inequality if it is a strict equality.

$$\mathcal{P}$$:

$$\mathcal{Q}$$:

Explain that what these polytopes represent is the scaled strategies when players maximum utilities are 1. So given, the action of an opponent, if the players’ utility is 1 they are playing a best response.

Ask each person in a pair to be the row or the column player.

Have the row player pick a vertex, then identify the strategy and it’s best response and then pick the corresponding vertex.

For example:

Row player picks $$(0, 1/3)$$ which has labels $$(0, 3)$$ and corresponds to the strategy $$(0, 1)$$. The best response to the second row is the first column which corresponds to vertex $$(0, 1/2)$$ which has labels $$(1, 2)$$.

Remind ourselves why these are the labels? (Refer to the defining properties of the polytopes).

Repeat with other vertices.

Aim to identify strategies that are best responses to each other:

• $$\sigma_r=(0, 1)$$ and $$\sigma_r=(0,1)$$
• $$\sigma_r=(3/4, 1/4)$$ and $$\sigma_r=(1/4,3/4)$$
• $$\sigma_r=(1, 0)$$ and $$\sigma_r=(1, 0)$$

Discuss how this relates to the labels again.

Finally show how this is implemented in nashpy:

>>> A = np.array([[1, -1], [-1, 1]])
>>> matching_pennies = nash.Game(A)
>>> for eq in matching_pennies.vertex_enumeration():
...     print(eq)
(array([0.5, 0.5]), array([0.5, 0.5]))

If there is time use support enumeration to compare.


text:
# Equivalence of Definitions of Convex Set in Vector Space

## Theorem

Let $\Bbb F \in \set {\R, \C}$.

Let $V$ be a vector space over $\Bbb F$.

Let $C \subseteq V$.

The following definitions of the concept of convexity are equivalent:

### Definition 1

We say that $C$ is convex if and only if:

$t x + \paren {1 - t} y \in C$

for each $x, y \in C$ and $t \in \closedint 0 1$.

### Definition 2

We say that $C$ is convex if and only if:

$t C + \paren {1 - t} C \subseteq C$

for each $t \in \closedint 0 1$, where $t C + \paren {1 - t} C$ denotes a linear combination of subsets.

## Proof

From the definition of the linear combination $t C + \paren {1 - t} C$, we have:

$t C + \paren {1 - t} C = \set {t x + \paren {1 - t} y : x, y \in C}$

for $t \in \R$.

So we have:

$t C + \paren {1 - t} C \subseteq C$
$t x + \paren {1 - t} y \in C$ for all $x, y \in C$ and $t \in \closedint 0 1$.

Hence the result.

$\blacksquare$

format: plain


text:
# Tutorial

This page was created from the LaTeX source in book/tutorial/ using latex2wiki

# Introduction

Welcome to a brief introduction to Madagascar. The purpose of this document is to teach new users how to use the powerful tools in Madagascar to: process data, produce documents and build your own Madagascar programs. To gradually introduce you to Madagascar, we have created a series of tutorials that are targeted to distinct audiences and designed to make you an experienced Madagascar user in a short-time period. The tutorials are divided by interest into three main categories:

• Users learn about Madagascar, how to use the processing programs, and build scripts.
• Authors learn how to build reproducible documents using Madagascar.

Each tutorial is designed to be completed in a short period of time. Additionally, each tutorial has hands-on examples that you should be able to reproduce on your computer as you go along with the tutorials. Most tutorials will use scripts that you can edit, modify, or play with to further gain experience and understanding. By the end of the tutorial series, you should be able to use all of the tools inside of Madagascar. Please note that this tutorial series does not explicitly show you how to process certain types of data, or how to perform common data processing operations (e.g. CMP semblance picking, time migration,etc.). Additional tutorials on those specific subjects will be added over time. The purpose of this document is simply to familiarize you with the Madagascar framework in a general sense. Before you go on, here are some notes on notation:

• important names, or program names are usually bold in the text. For example: sfwindow
• code snippets are always in the following formatting:
 sfwindow

# Users

The Users tutorials demonstrate how to use the Madagascar framework to create, process and visualize data, and to create reproducible scripts for processing data. The main goals of the Users tutorials are to learn about:

• the RSF file format,
• the command line interface,
• how to interact with files on the command line,
• commonly used programs,
• how to make plots in Madagascar,
• how to make reproducible scripts,
• how to use SCons and Python,
• how to visualize your data.

By the end of this tutorial group you should be able to fully use all of Madagascar's built-in tools for data processing and scripting. By using these tools, you'll be able to process data ranging from tens of megabytes to tens of terabytes in a reproducible fashion.

To begin, let's talk about the core principles of Madagascar, and the RSF file format.

The hierarchy of Madagascar. Fundamentally, everything builds off of the RSF file format. As you go up the chain the complexity level may increase, but the capabilities of the processing package increase as well.

### RSF file format

As previously mentioned, the lowest level of Madagascar is the RSF file format, which is the format used to exchange information between Madagascar programs. Conceptually, the RSF file format is one of the easiest to understand, as RSF files are simply regularly sampled hypercubes of information. For reference, a hypercube is a hyper dimensional cube (or array) that can best be visualized as an ${\displaystyle N}$-dimensional array, where ${\displaystyle N}$ is between 1 and 9 in Madagascar.

RSF hypercubes are defined by two files, the header file and the binary file. The header file contains information about the dimensionality of the hypercube as well as the data contained within the hypercube. Information contained in the header file may include the following:

• number of elements on all axes,
• the origin of the axes,
• the sampling interval of elements on the axes,
• the type of elements in the axes (i.e. float, integer),
• the size of the elements (e.g. single or double precision),
• and the location of the actual binary file.

Since we often want to view this information about files without deciphering it, we store the header file as an ASCII text file in the local directory, usually with the suffix .rsf . At any time, you can view or edit the contents of the header files using a text editor such as gedit, VIM, or Emacs.

The binary file is a file stored remotely (i.e. in a separate directory) that contains the actual hypercube data. Because the hypercube data can be very large (${\displaystyle 10s}$ of GB or TB) we usually store the binary files in a remote directory with the suffix .rsf@ . The remote directory is specified by the user using the DATAPATH environmental variable. The advantage to doing this, is that we can store the large binary data file on a fast remote filesystem if we want, and we can avoid working in local directories.

Cartoon of the RSF file format. The header file points to the binary file, which can be separate from one another. The header file, which is text, is very small compared to the binary file.

For more complete documentation on the RSF file format see the following links:

## Command line interface

Madagascar was designed initially to be used from the command line. Programmers create Madagascar programs (prefixed with the sf designation) that read and write Madagascar files. These programs are designed to be as general as possible, so that each one could operate on any dataset in RSF format, provided you also supply the correct parameters and have the right type of data for the program.

### Using programs

Madagascar programs follow the standard UNIX conventions for reading and writing RSF files to and from stdin and stdout . This is also the convention that Seismic Unix uses, so it should be familiar to SU users. For example: the program sfattr allows us to get attributes about an RSF file (mean, standard deviation, min, max, etc.) To get the attributes for a pre-computed file, we might use

sfattr < file.rsf
rms =       1.41316
mean =      0.999667
2-norm =       357.503
variance =      0.997693
std dev =      0.998846
max =       5.05567 at 36 8 27
min =      -3.59936 at 18 9 6
nonzero samples = 64000
total samples = 64000

We demonstrate how to read and write RSF files using sfwindow which is a program that allows us to select portions of an RSF file. When sfwindow is used without any additional parameters, we are able to make a copy of a file with a different filename. For example:

 sfwindow < file.rsf > file2.rsf

gives us two files, file.rsf and file2.rsf which are identical but not the same file. If your intention is simply to copy a file, you can also use sfcp . In addition to specifying files to read in and out on the command line we can specify the parameters for each program that are necessary for it to run, or to produce the desired result. The general format for specifying parameters on the command line is key=val , where key is the name of the parameter that you want to set, and val is the value of the parameter. There are four (4) types of values that are acceptable: integers, floating point numbers, booleans, or strings. Going back to the window program, we can specify the number of traces or pieces of the file that we want to keep like:

sfwindow < file.rsf n1=10 > file-win.rsf

### Self-documentation

Of course, we can specify as many parameters as we'd like on the command line. To figure out which parameters are needed for a specific program, just type the name of the program with no input files our output files on the command line to bring up a program's self-documentation. For example, sfwindow 's self documentation is:

NAME
sfwindow
DESCRIPTION
Window a portion of a dataset.
SYNOPSIS
sfwindow < in.rsf > out.rsf verb=n squeeze=y
j#=(1,...) d#=(d1,d2,...) f#=(0,...) min#=(o1,o2,,...)
n#=(0,...) max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)
PARAMETERS
float   d#=(d1,d2,...)  sampling in #-th dimension
largeint f#=(0,...)     window start in #-th dimension
int     j#=(1,...)      jump in #-th dimension
float   max#=(o1+(n1-1)*d1,o2+(n1-1)*d2,,...)
maximum in #-th dimension
float   min#=(o1,o2,,...)       minimum in #-th dimension
largeint n#=(0,...)     window size in #-th dimension
bool    squeeze=y [y/n]
if y, squeeze dimensions equal to 1 to the end
bool    verb=n [y/n]    Verbosity flag
USED IN
bei/dpmv/krchdmo
bei/dpmv/matt
bei/dwnc/sigmoid
bei/fdm/kjartjac
bei/fld/cube
bei/fld/shotmovie
bei/fld/synmarine
bei/fld/yc
bei/ft1/autocor
bei/ft1/ft2d
bei/krch/sep73
bei/sg/denmark
bei/sg/toldi
bei/trimo/mod
bei/trimo/subsamp
bei/vela/stretch
bei/vela/vscan
bei/wvs/vscan
cwp/geo2006TimeShiftImagingCondition/flat
cwp/geo2006TimeShiftImagingCondition/icomp
cwp/geo2006TimeShiftImagingCondition/zicig
cwp/geo2007StereographicImagingCondition/flat4
cwp/geo2007StereographicImagingCondition/gaus1
167 more examples listed in:
SOURCE
system/main/window.c
DOCUMENTATION
VERSION
1.3-svn

The self-documentation tells us the function of the program, as well as the parameters that are available to be specified. The parameter format is type - name=default value [options] and then a short description of the parameter. File parameters request a name of a file. For example:

file=file.rsf

Note: strings with spaces must be enclosed in quotation marks (e.g. 'my value') so that the Unix shell could interpret them correctly.

### Piping

Sometimes we want to chain multiple commands together without writing intermediate Madagascar RSF files in the process. We can avoid making intermediate files by using another standard UNIX construct, pipes. Pipes allow us to connect the standard output from one Madagascar program to the standard input to another program without first writing to a file. For example we could do the following without pipes:

sfwindow < file.rsf > file-win.rsf
sftransp < file-win.rsf > file2.rsf

Or we could do the equivalent using pipes on one line:

sfwindow < file.rsf | sftransp > file2.rsf

Pipes simply make these statements more compact, and allow us to reduce the number of files that we need to save to disk. Piping is very powerful, because there is no limit to the number of statements that you can pipe together. For example:

sfwindow < file.rsf | sftransp | sfnoise var=1 > file2.rsf

If you're using multiple programs, and do not want to save the intermediate files, then pipes will greatly reduce the number of files that you have to keep track of.

### Interacting with files from the command line

Ultimately though, 95% of your time using Madagascar on the command line will be to inspect and view files that are output by your scripts. Some of the key commands that are used to interact with files on the command line are:

• sfin , used to get header information,
• sfattr , used to get file attributes,
• sfwindow , used to select portions of RSF files,
• and sftransp , used to reorder files.

Here are detailed usage examples and explanations of what the above programs do: sfin is one of the most used program on the command line, because most often we simply need to check the dimensionality of our files to make sure that we have them in the correct order.

sfin file.rsf

file.rsf:
in="/var/tmp/file.rsf@"
esize=4 type=float form=native
n1=100         d1=0.004       o1=0          label1="Time" unit1="s"
n2=34          d2=0.1         o2=0          label2="Distance" unit2="km"
3400 elements 13600 bytes

sfattr is also commonly used from the command line to check files for correct values. Most often, we use sfattr to ensure that files are not filled with zeros, or with NaN's after a long computation, or to make sure that the values are reasonable. sfattr can be used to obtain basic statistics about the files as well.

sfattr < file.rsf

*******************************************
rms =             1
mean =             1
2-norm =       58.3095
variance =             0
std dev =             0
max =             1 at 1 1
min =             1 at 1 1
nonzero samples = 3400
total samples = 3400
*******************************************

sfwindow is used to select subsets of the data contained in an RSF file for computation elsewhere. Typically, you specify the data subset you want to keep using, the n, j, and f parameters which specify the number of indices in the arrays to keep, the jump in indices, and the first index to keep from the file in the respective dimension. For example if we want to keep the 15th-30th time samples from the first axis in file.rsf, we might use the following command:

sfwindow < file.rsf f1=15 n1=15 j1=1 > file-win.rsf

sftransp is used to reorder RSF files for other programs to be used. For example:

sftransp < file.rsf plane=12 > file-transposed.rsf

swaps the first and second axes, so that now the first axis is distance and the second axis is time. For more information about commonly used Madagascar programs please see the Guide to Madagascar programs.

## Plotting

VPLOT provides a method for making plots that are small in size, aesthetically pleasing, and easily compatible with Latex for rapid creation of production quality images in Madagascar.

### VPLOT

The VPLOT file format (.vpl suffix) is a self-contained binary data format that describes in vector format how to draw a plot on the screen using an interpreter. Since VPLOT is not a standard imaging format, VPLOT files must be viewed with third-party interpreters which we call pens. Each pen interfaces VPLOT with a third-party graphing library such as X11, plplot, opengl, and others. This flexibility makes VPLOT files almost as portable as standard image formats such as: jpeg, png, and gif. Unlike rasterized formats, VPLOT files can be scaled to any size without losing image quality.

### Creating plots

To generate VPLOT files, we need to pass our computed RSF files through VPLOT filters, that convert RSF data files to VPLOT files. The VPLOT filters are named by the type of plot that they produce. Table~(table:plotting) lists all of the available VPLOT filters. �egin{table} �egin{tabularx}{ extwidth}{|l|X| } \hline sfgraph & create line plots, or scatter plots

sfgrey & create raster plots or 2D image plots

sfgrey3 & create 3D image plots of panels (or slices) of a 3D cube

sfbox & make box-line plots

sfcontour & make contour plots

sfcontour3 & make contour plots of 3D surfaces

sfplotrays & make plots of rays

\hline \end{tabularx} \caption{List of available plotting programs in Madagascar}

(table:plotting)

\end{table} To actually create a plot, we can use the plotting programs on the command line in the same fashion that we would use a Madagascar program:

sfspike n1=100 | sfnoise > junk.rsf
sfgraph < junk.rsf title="noise" > junk.vpl

### Visualizing plots

In this example, we create a single trace full of noise and then send it to sfgraph to produce a single VPLOT file, junk.vpl. As you may have noticed, this only creates the file which is useful for saving the plot,does not allow us to visualize the data. To visualize the data we need to use a pen , which tells your machine how to actually draw the plot. A typical Madagascar installation will have multiple pens available for you to use. By default, you should use sfpen which will pick the best pen available for you. You can use sfpen to visualize your plots in the following manner:

sfpen < junk.vpl

This will pop up a screen on your window with the plot shown. Depending on which pen you are using you may be able to interact with the pen interface to control various parameters of the plot as shown by the buttons at the top of the screen. Depending on the pen that you are using, there may be keyboard shortcuts to many of the buttons. NOTE: oglpen uses a mouse interface that can be accessed by right-clicking on the plot.

### Converting VPLOT to other formats

If you want to build reports or documents using other programs, or want to send your images to someone who does not have Madagascar you will need to convert your VPLOT files to other image formats for transfer. To convert a VPLOT plot to another format use the tool vpconvert . vpconvert allows you to convert VPLOT files to any of the following formats, provided that you have the appropriate third-party libraries installed:

• avi,
• eps,
• gif,
• jpeg/jpg,
• mpeg/mpg (movie format),
• pdf,
• png,
• ppm,
• ps,
• svg,
• and tif.

Here's an example of how to use vpconvert :

vpconvert junk.vpl format=jpeg

NOTE: details on how to install these third-party libraries are not included with the Madagascar library, and we provide no support on installing them. Most users will be able to install them using either package management software (on Linux and Mac) or pre-compiled binaries.

\documentclass[12pt]{geophysics} \usepackage{hyperref} \usepackage{comment} \usepackage{verbatim} \usepackage{moreverb} \usepackage{tabularx} \setfigdir{Fig}

Madagascar's command line interface allows us to create, manipulate and plot files. Often though, we want to create scripts that will perform these operations automatically for us. Scripting is especially important when processing large amounts of data, or performing a complex chain of file manipulations in order to ensure that operations are completed in the right order or with proper parameters. In Madagascar, there are two main ways of creating scripts: shell scripts, and Python scripts using SCons.

### Shell scripting

Shell scripting is the first option for creating scripts. In shell scripting we simply copy the command lines that we would use and paste them into a file that is recognized by either BASH, C-shell or another shell of your choosing. Shell scripting may be familiar to users of other packages as SU, because it is the primary method of scripting in other packages. An example of a Madagascar shell script is shown below:

#!/bin/bash
sfspike n1=100 > junk.rsf
< junk.rsf sfgraph > junk.vpl

For simple processing flows, shell scripting is a quick and easy approach to saving your processing flow. However, shell scripts quickly become unmanageable when more complicated processing flows are used. Additionally, shell scripts have no way to avoid repeating commands that have already been successfully run, which causes shell scripts to spend a significant amount of time duplicating already completed work. Because of these issues, Madagascar's main scripting option is to use a build manager called SCons for scripting instead of shell scripts.

### SCons

SCons is a build manager written in 100\

### SConstructs and commands

SCons scripts are referred to as SConstructs. In order to use SCons, you must create an SConstruct in the local directory where you want to work. Since SCons is written in Python, an SConstruct is simply a text file written using Python syntax. If you don't know Python, you can still use SCons, because the syntax is simple. First, a primer on Python syntax. In SConstructs we are going to deal with Python functions and strings. Python functions are simple, and should be familiar to anyone who has used a programming language. For example, calling a Python function, foo, looks like:

One argument - foo(1).
Many arguments - foo(1,2,3,4,5,123)

Python functions can take many arguments, and arguments of different types, but the syntax is the same. Python strings are also very similar to other programming languages. In Python anything inside double quotes is automatically considered to be a string, and not a variable declaration. However, Python also supports a few notations to indicate strings (or long strings) as shown below:

"this is a string"
'this is a string'
"""this is a string"""
"'this is a string"'

Somtimes in Python you will need to nest a string within a string. To do use one of the string representations for the outer string, and use a different one for the inner string. For example:

"""sfgraph title="junk plot" """  OR
"' sfgraph title="junk plot" "'   OR
'   sfgraph title="junk plot" '

Fundamentally, SConstructs are composed of only three commands: Flow , Plot and Result . The first command is Flow . A Flow creates a relationship between the input file, the output file, and the processing command used to create the output file from the input file. The syntax for a Flow is:

Flow(output file,input file,command)

where, target and source are file names (strings), and command is a string that contains the Madagascar program to be used, along with the command line parameters needed for that program to run. For example:

Flow("spike1","spike","sfadd scale=4.0") ,

creates a dependency relationship between the output file 'spike1' and the input file 'spike'. The dependency indicates that 'spike1' cannot be created without 'spike' and that if 'spike' changes then 'spike1' also changes. The relationship in this case is that 'spike1' should be 'spike' scaled by four times. The equivalent command on the command line would be:

< spike.rsf sfadd scale=4.0 > spike1.rsf

Note: the file names of the input and output files do not need to include '.rsf' on the end of the files as SCons automatically adds the suffix to all of our file names. Now that we can create relationships between files using Flow s, we can create an SConstruct to do all of our data processing using SCons. However, we often want to visualize the results of our processing in order to quality control the results. In order to create Plot s (or other visualizations) in Madagascar we have two additional SCons commands: Plot and Result . Plot and Result tell SCons how to use Madagascar's plotting programs to create visualizations of files on the fly after they have been computed. The syntax for both Plot and Result is as follows:

Plot(input file, command)
OR
Result(input file, command)

In both cases, the Plot or Result command tells SCons to build a VPLOT file with same file name as the input file (with the .vpl suffix instead) from the input file using the command provided. For example, if we want to make a graph of a file we could use:

Plot("spike1","sfgraph pclip=100")

Behind the scenes, SCons establishes that we want to use "spike1.rsf" to create a Plot called "spike1.vpl" using sfgraph. The equivalent command line operation is:

< spike1.rsf sfgraph pclip=100 > spike1.vpl

Result can be used in the same way as Plot , illustrated above. At this point, you might be asking yourself, what's the difference between Plot and Result ? The answer is that Plot creates all VPLOT files in the local directory, whereas Result creates its VPLOT files in a subdirectory called Fig. Fig is a location used to store Plot s that we want to later use when creating papers using Latex. By default, you should use Plot when creating visualizations. Only use Result when you want to save something to be used in a paper. Note: since the VPLOTs from Plot and Result are placed in different locations you can use both Plot and Result for a single RSF file, but create two different plots for the same file.

### Creating an SConstruct

Now that we have the three SConstruct commands, we can write our first SConstruct. To do so, open the SConstruct file in your favorite text editor. Before we can create any Flow , Plot or Result statements we have to add a first statement to the SConstruct. Enter the following statement (verbatim) into your new SConstruct:

from rsf.proj import *

This statement tells SCons where to find the Flow , Plot and Result commands, and must be included in every SConstruct. After that statement has been entered, you can enter as many Flow , Plot and Result commands as you wish making sure to use proper syntax. It's helpful to use a text editor that has Python syntax highlighting, as that will help you find and remedy strings that are not closed. You can also create Python comments using the ${\displaystyle \#}$ mark to indicate the beginning of a comment to help document your SConstructs.

Lastly, you must include the following statement at the end of your SConstruct:

End()

This statement tells SCons that the script is done and that it should not look for anything else in the script. Make sure to include this statement as the very last item in every SConstruct, otherwise you will get interesting error statements during execution. Here's a sample SConstruct:

from rsf.proj import *  # Remember, this statement comes first... ALWAYS

'''Flow''' ("spike",None,"sfspike n1=100 k1=50")
'''Flow''' ("noise","spike1","sfnoise")

'''Plot''' ("spike",'sfgraph title="spike" ' ) # Note string nesting
'''Plot''' ("spike1",'sfgraph title="spike1" ')
'''Plot''' ("noise",'sfgraph title="noisy" ')

'''Result''' ("noise",'sfgraph title="noisy" pclip=75 ')

End() # Remember, this always ends the script.

Note: you do not have to order your Flow , Plot and Result commands as shown above. You can mix Flow , Plot and Result in any order. SCons automatically establishes the relationships between related files and commands.

### Executing SCons

Now that you have an SConstruct, you can start processing data the Madagascar way. To do so open a terminal and navigate to the local directory where your SConstruct is located. To execute your SConstruct simply run: scons . When you run SCons, it will check to make sure that all necessary dependencies are found and that all of your commands inside the SConstruct are valid. If not, SCons will return an error message showing you where you made a mistake. If everything is OK, then SCons will begin creating your files in the local directory and will output its progress as it executes the Madagascar programs on the command line. For example, running the sample SConstruct from above should show something similar to the following output:

scons: Reading SConscript files ...
scons: Building targets ...
/opt/rsf/bin/sfspike n1=100 k1=50 > spike.rsf
< spike.rsf /opt/rsf/bin/sfadd scale=4.0 > spike1.rsf
< spike1.rsf /opt/rsf/bin/sfnoise > noise.rsf
< spike.rsf /opt/rsf/bin/sfgraph title="spike" > spike.vpl
< spike1.rsf /opt/rsf/bin/sfgraph title="spike1" > spike1.vpl
< noise.rsf /opt/rsf/bin/sfgraph title="noisy" > noise.vpl
< noise.rsf /opt/rsf/bin/sfgraph title="noisy" pclip=75 > Fig/noise.vpl
scons: done building targets.

If the execution of scons ends with, "scons: done building targets" then the script completed successfully. Check your local directory for your output files.

### Common errors in SConstructs

There are two common errors that most users will experience when executing SConstructs: missing dependency errors, and misconfiguration errors. We'll demonstrate both of these errors to help new users troubleshoot them below. The first error is caused by missing a dependency in the SConstruct. To introduce this error into your SConstruct modify the sample SConstruct from above to the following:

from rsf.proj import *  # Remember, this statement comes first... ALWAYS

'''Flow''' ("noise","spike1","sfnoise")

'''Plot''' ("spike",'sfgraph title="spike" ' ) # Note string nesting
'''Plot''' ("spike1",'sfgraph title="spike1" ')
'''Plot''' ("noise",'sfgraph title="noisy" ')

'''Result''' ("noise",'sfgraph title="noisy" pclip=75 ')

End() # Remember, this always ends the script.

Now when you run scons , you should get an error message:

scons: Reading SConscript files ...
scons: Building targets ...
scons: *** [spike1.rsf] Source spike.rsf' not found, needed by target spike1.rsf'.
scons: building terminated because of errors.

In this case, SCons tells you exactly which file is missing and which output file is missing one of its dependencies. To solve this problem, add the Flow to create 'spike' to the SConstruct. If your SConstruct uses a file that is not created inside the SConstruct, and is complaining about a missing dependency, then make sure the file you are looking for is in a location that the SConstruct can access. The second error, is caused by having a misconfigured command. To demonstrate this type of error change your SConstruct to:

from rsf.proj import *  # Remember, this statement comes first... ALWAYS

'''Flow''' ("spike",None,"sfspike n1=100 k1=50")
'''Flow''' ("spike1","spike","sfasd scale=4.0")
'''Flow''' ("noise","spike1","sfnoise")

'''Plot''' ("spike",'sfgraph title="spike" ' ) # Note string nesting
'''Plot''' ("spike1",'sfgraph title="spike1" ')
'''Plot''' ("noise",'sfgraph title="noisy" ')

'''Result''' ("noise",'sfgraph title="noisy" pclip=75 ')

End() # Remember, this always ends the script.

In this case, we've introduced a typo into one of our commands. When running scons, the result is:

scons: Reading SConscript files ...
scons: Building targets ...
/opt/rsf/bin/sfspike n1=100 k1=50 > spike.rsf
< spike.rsf sfasd scale=4.0 > spike1.rsf
scons: *** [spike1.rsf] Error 127
scons: building terminated because of errors.

Again, the error message is pretty descriptive and could help you track down the error relatively quickly. It's important to note that in this case, the error was caught after SCons tried to execute the command and failed to do so, whereas the dependency error was caught before any commands were executed. This means that this typo error would kill a script that's been running a long time without any issues up till that point. Fortunately, SCons would restart the script at the point of failure thereby saving you all the additional time to recompute everything before this point in the script. These are only two of the most common errors that new users will see. For additional information about debugging SConstructs, or for exceptionally strange errors please consult the RSF users mailing list.

Here are some additional SCons commands that are useful to know.

#### Viewing Plots

If you're running an SConstruct and want to view the plots that it creates as it creates them, then you can use: scons view to force SCons to show the plots interactively. Doing so allows you to view your output at runtime and stop the SConstruct as it's running if you don't like what you see.

#### Viewing only one plot

If you want to view the plot associated with only a single file you can tell SCons to view that plot by using the command: scons file.view where file is the filename of the item that you want to view. For example: scons spike.view would show the plot of the spike.rsf file. The advantage to using this command is that SCons will only build the dependencies needed to view that specific plot, which can save you a lot of time in longer processing scripts.

#### Building specific targets

If you want to build a specific RSF file, or a few specific RSF files you can simply specify them on the command line when you execute SCons as follows: scons file.rsf file2.rsf file3.rsf ... . The advantage to doing this, is that SCons will only build those files and their dependencies instead of running through the entire script.

#### Cleaning up

After we've executed our SConstruct and viewed the results of the processings flows, we might decide that we want to clean up our project and go work on something else. Normally, one would have to delete all of the files and then move on, but SCons automates this process using the command: scons -c . Simply execute it in the local directory and SCons will remove all of the built RSF files, and VPLOT files. SCons will not remove files that it does not have rules for.

#### Dry-runs

Sometimes we want to test an SConstruct through the end of the script without waiting for it to run completely. To do so, we can use scons -n which tells SCons to simulate an actual execution. During a dry-run SCons will check all of the commands, and dependencies to ensure that they exist and are properly configured. If not, then SCons will tell you which commands are misconfigured. This command can save you hours of debugging! Use it liberally.

#### Parallel executions

For long scripts we can use parallel execution to run multiple processing commands at the same time. Parallel execution requires that the commands can function independently of one another (i.e. there are commands that do not depend on each other's output). To use parallel execution use: pscons which launches the maximum number of parallel jobs that your computer can handle at once. Parallel execution can greatly speed up your processing flows if SCons can parallelize it. In the worst case, SCons won't be able to parallelize your script and it will run at the same speed as if you just used scons .

### Final thoughts

At this point you should have a solid understanding of how to use SCons and create SConstructs to script your Madagascar processing flows. Admittedly, SCons is somewhat complicated and difficult to understand at first, but don't give up. By using SCons, you are able to create powerful Madagascar scripts that are completely reproducible and enjoy the benefits of using a powerful build management system. However, we have not shown you the most useful aspects of SCons, which are demonstrated in the next tutorial, where we show how to integrate Python with SCons, thereby making processing flows that are very powerful.

\documentclass[12pt]{geophysics} \usepackage{hyperref} \usepackage{comment} \usepackage{verbatim} \usepackage{moreverb} \usepackage{tabularx} \setfigdir{Fig}

Now that you have a grasp of how to use SCons to put together simple processing flows, we're going to show you how to abuse SCons to make more advanced processing flows that can handle multiple input and output files properly. Additionally, we're going to demonstrate some SCons tricks that make your life easier, and allow you to work faster, and smarter.

### Multiple input files

Many Madagascar programs require multiple input files and/or output multiple files. In order for SCons to properly recognize that these additional files are dependencies for a specific output file we have to change the syntax that we use for Flow , Plot and Result statements. To do so, we'll need to use Python lists to help us keep everything together when using our SCons commands. We first discuss the case where we need multiple input files. An example of a Madagascar program that requires multiple input files is sfcat . For reference, sfcat is used to concatenate multiple files together, essentially a file manipulation program. For example, we might use sfcat on the command line in the following fashion: �egin{verbatimtab}[4] < file.rsf sfcat axis=2 file1.rsf file2.rsf file3.rsf file4.rsf > catted.rsf \end{verbatimtab} To replicate this behavior using SCons we need to tell our Flow statements about the presence of multiple input files. Important: if we do not indicate to SCons that we have multiple input files then the dependency chain will not be correct and we cannot guarantee our results are correct . We can easily tell SCons of the presence of multiple input files by using a Python list as our input file, instead of a string: �egin{verbatimtab}[4] Flow('catted',['file','file1','file2','file3','file4'], 'sfcat axis=2 $\displaystyle {SOURCES[1:-1]}') \end{verbatimtab} As you may have noticed, there are two new items in this '''Flow''' statement, but let's start by discussing only the list of file names: '''['file','file1','file2','file3','file4']''' . The list of file names is simply a Python list of strings that contains each of the names of the files that we want to use in this Flow command. As usual, we don't have to append the '.rsf' suffix to the end of these names because SCons adds it for us. The second new part to the '''Flow''' command is: '''${SOURCES[1:-1]''' }, referred to as the SCons source list, which tells SCons about the presence of additional input files in the command, and to substitute the names into the command automatically. Without this command, SCons would not include the files in the final command. As an example of what the SCons source list does, compare the two SConstructs below against one another. The top is correct, the bottom is incorrectly configured: �egin{verbatimtab}[4] # Correct from rsf.proj import * Flow('file',None,'spike n1=100') Flow('file1',None,'spike n1=100') Flow('file2',None,'spike n1=100') Flow('file3',None,'spike n1=100') Flow('file4',None,'spike n1=100') Flow('catted',['file','file1','file2','file3','file4'], 'sfcat axis=2$ {SOURCES[1:-1]}') End() \end{verbatimtab} # Wrong from rsf.proj import * Flow('file',None,'spike n1=100') Flow('file1',None,'spike n1=100') Flow('file2',None,'spike n1=100') Flow('file3',None,'spike n1=100') Flow('file4',None,'spike n1=100') Flow('catted',['file','file1','file2','file3','file4'],'sfcat axis=2') End()  If you noticed the command line output from SCons, you would find that for the incorrect SConstruct, SCons ran the following command: < file.rsf sfcat axis=2 > catted.rsf  which is not correct. This is because SCons was not informed that the additional sources actually are used inside the command and did not substitute them in. The SCons source list contains a reference to all of the file names that we passed in our Python list earlier. In order to access those names we have to use a specific notation, but it is essentially a Python list enclosed in curly brackets that begins with a$. Since the source list is a Python list, we can get the file names in a few ways if we follow standard Python list conventions. Standard Python list conventions are:

• List indexing starts with index 0,
• Lists may be negatively indexed, which returns the items from the end (e.g. LIST[-1]),
• Lists may be sliced using the LIST[start:end] notation, where start and end are indices,
• List slicing indices are inclusive for the starting index, and exclusive for the ending index (e.g. LIST[0:4] returns LIST[0],LIST[1],LIST[2],LIST[3] but NOT LIST[4],
• Open slicing indices may be used (e.g. LIST[2:] gets everything from index 2 to the end, and LIST[:4] returns everything from 0 to but not including 4).
• Negative and positive indices may be used together (e.g. LIST[1:-1] returns all elements but the first and last).

These are the most useful conventions to remember, and the ones you will most frequently see. Please see the Python documentation (freely available online) for more information about dealing with Lists. Using the above conventions the following Flow statements are all equivalent for lettings SCons know about the presence of multiple input files: �egin{verbatimtab}[4] Flow('catted',['file','file1','file2','file3','file4'], "' sfcat axis=2 ${\displaystyle {SOURCES[1]}}${SOURCES[2]}

   ${\displaystyle {SOURCES[3]}}${SOURCES[4]}

"') Flow('catted',['file','file1','file2','file3','file4'], "' sfcat axis=2 $\displaystyle {SOURCES[1:5]} "') Flow('catted',['file','file1','file2','file3','file4'], "' sfcat axis=2$ {SOURCES[1:-1]} "') \end{verbatimtab} Note: never use SOURCES[0] because SOURCES[0] corresponds to 'file' which is already used by SCons for standard input. Also, never use open slicing on the SOURCES list, because at the end of the SOURCES list are extra items added by SCons for safe keeping that will break the command if accidentally used.

### Multiple outputs

For multiple outputs, we can use the same conventions as before, except we specify a list of output files instead of input files, and we use the TARGETS SCons list, instead of SOURCES. For example:

### Classes

The least used, but most powerful part of Python that you can bring into your SConstructs are Python classes. For example, if you are writing a script to process multiple models in the exact same way, but that have different parameters you would have to write separate Flow statements to process each of them, OR you could write a Python class that takes the model parameters and uses those parameters to generate Flow statements automatically, similar to functions. However, a class can allow you to group functions together into a single coherent body and allow you to drastically reduce the amount of code that must be reused. We refer the reader to the Python documentation for more information on creating and using classes.

### Final thoughts

Congratulations on completing the Madagascar User tutorial series. Now, you should have all the tools to: use Madagascar programs, write SConstructs to script your processing flows, and combine Python with SCons to make powerful scripts that can process data in ways not previously possible. From here, you can continue learning about how to write your own Madagascar programs, or learn about how to make reproducible documents using the Madagascar framework.


text:
### Problem 13

View
Georgia Southern University
Problem 12

are given.
a. What are the critical points of $f ?$
b. On what open intervals is $f$ increasing or decreasing?
c. At what points, if any, does $f$ assume local maximum and minimum values?
$$f^{\prime}(x)=x^{-1 / 2}(x-3)$$

see the graph

## Discussion

You must be signed in to discuss.

## Video Transcript

all right. So derivative or function is given by OK, X to the minus one half of her ex mines three bomb is going to write that his ex minus three over square root of X. Good. Okay. And so if we're looking for a critical points well, we see the X equals three is going to make f prime undefined. And then also, X equals zero X equals three is going to make a private call zero Sorry. And then X equals zero is gonna make of prime on to find. So we need to consider those values. Okay. And then we want to know where is f increasing and decreasing. Well, fans era and three, we can look enough crime to see where l promise positive or negative Tell us where is increasing or decreasing. So less than zero f crime was going to be undefined because we'll be taking the square root of a night, remember? And then between zero and three it looks like the derivative is negative. Good morning. And then, um let's see between, uh, for ex greater than three, the derivative is going to be positive. And so it looks like our function no. Okay, he's going to start at zero and it's going to be decreasing between zero and three and then an increasing from three to infinity and then or extreme A. It looks like we have a local man and X equals three and then no local Max because it never. The function never changes from being increasing, decreasing and only changes from seem decreasing to increasing it through It's a local man.


text:
# DALEX v0.1.1

0

0th

Percentile

## Descriptive mAchine Learning EXplanations

Machine Learning (ML) models are widely used and have various applications in classification or regression. Models created with boosting, bagging, stacking or similar techniques are often used due to their high performance, but such black-box models usually lack of interpretability. 'DALEX' package contains various explainers that help to understand the link between input variables and model output. The single_variable() explainer extracts conditional response of a model as a function of a single selected variable. It is a wrapper over packages 'pdp' and 'ALEPlot'. The single_prediction() explainer attributes arts of model prediction to articular variables used in the model. It is a wrapper over 'breakDown' package. The variable_dropout() explainer assess variable importance based on consecutive permutations. All these explainers can be plotted with generic plot() function and compared across different models.

## Functions in DALEX

 Name Description explain Create Model Explainer plot.single_prediction_explainer Plots Local Explanations (Single Prediction) print.explainer Prints Explainer Summary single_prediction Explanations for a Single Prediction plot.single_variable_explainer Plots Marginal Model Explanations (Single Variable Responses) plot.variable_dropout_explainer Plots Global Model Explanations (Variable Drop-out) single_variable Marginal Response for a Single Variable theme_mi2 MI^2 Theme variable_dropout Loss from Variable Dropout No Results!


text:
# [Tex/LaTex] troubleshoot needed for LaTeX Error: Command \item invalid in math mode

beamererrorsitemizemath-mode

Can someone please troubleshoot this?

It gives me an

\item invalid in math mode

although I use a very similar casing on a previous frame.

\documentclass[mathserif]{beamer}
\usepackage{beamerthemesplit}
\usepackage{amsmath}
\usepackage{amsfonts}
\begin{document}
\begin{frame}[shrink=20]
Requiring the partition function to be modular invariant, gives some properties to $\epsilon(\alpha,\beta)$.
\begin{itemize}
\item Under $\tau \rightarrow \tau+1$
$$\{\alpha,\beta\} \rightarrow e^{-i\pi n(\alpha)/8}\{\alpha,\bar \alpha \beta\}.$$
This will require $\epsilon(\alpha,\beta)=\varepsilon_\alpha\epsilon(\alpha,\bar \alpha \beta\)$.
\item Under $\tau \rightarrow -\frac{1}{\tau}$
$$\{\alpha,\beta\} \rightarrow e^{i\pi n(\alpha \cap \beta)/4}\{\beta, \alpha\}.$$
This will require $\epsilon(\alpha,\beta)=\delta_\alpha\delta_\beta\epsilon(\beta, \alpha)\varepsilon_{\alpha \cap \beta}^{-2}$.
\end{itemize}
In the equations above $\varepsilon_\alpha=e^{-i\pi n(\alpha)/8}$.
\end{frame}
\end{document}

#### Best Answer

You have a spurious \) before the start of the second \item, which should only be ).


text:
## usb – Is display MacBook Pro fuse or software protected against overpowered/ short circuit?

I did accidentally overpowered (12v) the USB Port of My MacBook Pro 2015 by putting a powered male usb. (I know that is stupid of me).
Immediately the display and the light of my keyboard went off.
I hear on the sound of the MacBook that the Mac is still alive.
Now I am questioning myself.
-are the display and keyboard light dead and have to be replaced?
-is there any protection mode designed by smart apple engineers to protect such a rare situation. By for example a fuse (for backlight/display, I found on YouTube the replacement instructions already. For keyboard I didn’t yet found any) or a software mode?

So, Any help, hint, instruction, link and or advice is welcome and very much Appreciated.

Thanks!

## complexity theory – What is the comparator circuit?

The standard circuits $$AC^i$$, $$NC^i$$ are constructed using $$AND$$, $$OR$$ and $$NOT$$ of various fan-ins, fan-outs and depths.

What is the comparator gate constituted from?

Structurally why is it believed $$NC^i$$ is not in any $$CC^j$$ if $$igeq 1$$ and why is it believed $$CC^i$$ is not in any $$NC^j$$ if $$igeq 1$$ (refer https://arxiv.org/abs/1208.2721 for the conjecture $$NC$$ and $$CC$$ are incomparable)?

## The datasheet says that USB operates on 1.8v instead of 3.3v, do I need some sort of logic level shifter in my circuit?

I’m trying to design a breakoutboard and connect the coral chip to my imx6 SoC vis usb. I’m assuming that the imx6 is using 3v3 logic because it doesn’t indicate otherwise and everything I’ve connected to it via usb thus far works fine. The data sheet of the Coral Edge TPU says that it operates on 1.8V. Do I need to account for this somehow in my design by assing a logic level shifter or something like that to my schematic? I don’t even really know if USB operates at 3.3v logic level either I’m just confused about why they would say that in the datasheet.

## Upper bound for the size of a boolean circuit that computes a function \$f: {0,1}^n rightarrow {0,1}\$

I am trying to find an upper bound for the size of a boolean circuit of size $$s$$ that computes a function
$$f: {0,1}^n rightarrow {0,1}$$.

I believe an upper bound would be $$2s$$ since the usual convention is not to count “not” gates. Therefore, “not” gates can be pushed to immediately follow the input gates. So, ignoring “not” gates affects the size by at most $$n$$.

Im thinking of it intuitively but can someone point me to a more formal proof of this claim?

## How can you convert the depth of a boolean circuit to its size?

I know that the depth of a circuit is the maximal length from an input gate to the output gate of the circuit and its size is its number of gates.

Is there a formula that you can go from depth to size and can someone explain the steps?

## algorithms – A person wants to connect n circuit points to the clock signal

A person wants to connect n circuit points to the clock signal. Now, the clock signal is going to pass parallel to the x-axis and all those circuit points are going to be connected by vertical to the clock line. Suppose the widths of the vertical wires in the given diagram also vary varying.

If the coordinates($$x_i$$,$$y_i$$) for each circuit point $$c_i$$ to be connected are given, find y=$$y_c$$, through which the clock line should pass to minimize the expression

PS: I don’t know latex that’s why I had to post snippets.

## computer architecture – Changing the combinatorial circuit as little as possible to present correct prime numbers?

I’m very new to CS and I’ve been thinking long and hard about a certain problem of an exercise.

We are given a combinatorial circuit which is supposed to show prime numbers for y=1, however, it doesn’t work for the number 2, for 2 it’s y=0.

Here is the operator tree. https://ibb.co/bgGGQTP

And the combinatorial circuit: https://ibb.co/kSSP8hb

I’ve already constructed a new combinatorial circuit with minimal polynomial (making a draft for a new table, new dnf form, minimalising it, etc). The exercise states this is exactly what you are NOT supposed to do.
You are supposed to repair it, with as little change as possible.

So, I’ve tried to negate some conjunctions from the original DNF, and changing the AND3 gates to AND2 Gates to AND4 gates. etc, etc. None of this worked.

I’m getting crazy here, is there any easy solution I overlooked?

Any help would be really appreciated!
I’m very sorry for my bad English.
Thank you so much for reading.

## complexity theory – Prove lower bound on boolean circuit

Given matrix $$A in {0,1}^{n times m}$$ with $$n$$ rows and $$m = 2^n – 1$$ columns. Where $$j$$-th column is binary decomposition of $$j$$ ($$j = 1 dots 2^n – 1$$). For example, if $$n = 3$$:

$$A = begin{pmatrix} 0 & 0 & 0 & 1 & 1 & 1 & 1 \ 0 & 1 & 1 &0 & 0& 1 & 1 \ 1 & 0 & 1 & 0 & 1 & 0 & 1 end{pmatrix}$$

This matrix calculates $$Ax$$ over $$({0,1}, oplus)$$, where $$x in {0,1}^m$$.

For example, if $$n = 3$$ it calculates $$(x_4 oplus x_5 oplus x_6 oplus x_7,; x_2 oplus x_3 oplus x_6 oplus x_7, ; x_1 oplus x_3 oplus x_5 oplus x_7)^T$$

This is a Boolean function with $$m = 2^n – 1$$ inputs and $$n$$ outputs. It can be represented by boolean circuit $$S$$ with $$m = 2^n – 1$$ inputs and $$n$$ outputs, where only XOR gates are allowed. Each XOR gate in circuit $$S$$ is binary — it takes exactly two inputs.

Let us denote by $$size(S)$$ number of gates in $$S$$ (we don’t count inputs as gates, but we count outputs as gates).

It is not hard to prove upper bound: $$size(S) le 2(2^n – 1 – n)$$.

Problem: Prove lower bound: $$size(S) ge 2(2^n – 1 – n)$$.

## Telia price point 1G and 10G circuit

Hello,

can someone pvt me Telia current price brackets ?

## computer architecture – What is combinational circuit?

I’m reading the Digital Design and Computer Architecture by David Harris, Sarah Harris. The authors give the following definition of combinational logic:

A combinational circuit’s outputs depend only on the current values of
the inputs; in other words, it combines the current input values to
compute the output… A combinational circuit is memoryless, but a
sequential circuit has memory. The functional specification of a
combinational circuit expresses the output values in terms of the
current input values.

However, they claim this circuit is not combinational:

because “node n6 connects to the output terminals of both I3 and I4”. Indeed, it’s one of the designated signs when a scheme can not be combinational but, according to the authors:

Certain circuits that disobey these rules are still combinational, so
long as the outputs depend only on the current values of the inputs.

As I’m able to catch on, the aforementioned circuit is the case: its output is 1 if and only if its inputs are both 1, otherwise the output is 0. So the output is defined as a function of the inputs (the AND function).


text:
sbv-8.1: SMT Based Verification: Symbolic Haskell theorem prover using SMT solving.

Documentation.SBV.Examples.CodeGeneration.PopulationCount

Description

Computing population-counts (number of set bits) and automatically generating C code.

Synopsis

Reference: Slow but obviously correct

Given a 64-bit quantity, the simplest (and obvious) way to count the number of bits that are set in it is to simply walk through all the bits and add 1 to a running count. This is slow, as it requires 64 iterations, but is simple and easy to convince yourself that it is correct. For instance:

>>> popCountSlow 0x0123456789ABCDEF
32 :: SWord8

Faster: Using a look-up table

Faster version. This is essentially the same algorithm, except we go 8 bits at a time instead of one by one, by using a precomputed table of population-count values for each byte. This algorithm loops only 8 times, and hence is at least 8 times more efficient.

pop8 :: [SWord8] Source #

Look-up table, containing population counts for all possible 8-bit value, from 0 to 255. Note that we do not "hard-code" the values, but merely use the slow version to compute them.

Verification

We prove that popCountFast and popCountSlow are functionally equivalent. This is essential as we will automatically generate C code from popCountFast, and we would like to make sure that the fast version is correct with respect to the slower reference version.

States the correctness of faster population-count algorithm, with respect to the reference slow version. Turns out Z3's default solver is rather slow for this one, but there's a magic incantation to make it go fast. See http://github.com/Z3Prover/z3/issues/1150 for details.

>>> let cmd = "(check-sat-using (then (using-params ackermannize_bv :div0_ackermann_limit 1000000) simplify bit-blast sat))"
>>> proveWith z3{satCmd = cmd} fastPopCountIsCorrect
Q.E.D.

Code generation

Not only we can prove that faster version is correct, but we can also automatically generate C code to compute population-counts for us. This action will generate all the C files that you will need, including a driver program for test purposes.

Below is the generated header file for popCountFast:

>>> genPopCountInC
== BEGIN: "Makefile" ================
# Makefile for popCount. Automatically generated by SBV. Do not edit!

# include any user-defined .mk file in the current directory.
-include *.mk

CC?=gcc
CCFLAGS?=-Wall -O3 -DNDEBUG -fomit-frame-pointer

all: popCount_driver

popCount.o: popCount.c popCount.h
${CC}${CCFLAGS} -c $< -o$@

popCount_driver.o: popCount_driver.c
${CC}${CCFLAGS} -c $< -o$@

popCount_driver: popCount.o popCount_driver.o
${CC}${CCFLAGS} $^ -o$@

clean:
rm -f *.o

veryclean: clean
rm -f popCount_driver
== END: "Makefile" ==================
== BEGIN: "popCount.h" ================
/* Header file for popCount. Automatically generated by SBV. Do not edit! */

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
#include <math.h>

/* The boolean type */
typedef bool SBool;

/* The float type */
typedef float SFloat;

/* The double type */
typedef double SDouble;

/* Unsigned bit-vectors */
typedef uint8_t  SWord8;
typedef uint16_t SWord16;
typedef uint32_t SWord32;
typedef uint64_t SWord64;

/* Signed bit-vectors */
typedef int8_t  SInt8;
typedef int16_t SInt16;
typedef int32_t SInt32;
typedef int64_t SInt64;

/* Entry point prototype: */
SWord8 popCount(const SWord64 x);

== END: "popCount.h" ==================
== BEGIN: "popCount_driver.c" ================
/* Example driver program for popCount. */
/* Automatically generated by SBV. Edit as you see fit! */

#include <stdio.h>
#include "popCount.h"

int main(void)
{
const SWord8 __result = popCount(0x1b02e143e4f0e0e5ULL);

printf("popCount(0x1b02e143e4f0e0e5ULL) = %"PRIu8"\n", __result);

return 0;
}
== END: "popCount_driver.c" ==================
== BEGIN: "popCount.c" ================
/* File: "popCount.c". Automatically generated by SBV. Do not edit! */

#include "popCount.h"

SWord8 popCount(const SWord64 x)
{
const SWord64 s0 = x;
static const SWord8 table0[] = {
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3,
3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4,
3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2,
2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5,
3, 4, 4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5,
5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3,
2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4,
4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4,
4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6,
5, 6, 6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5,
5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
};
const SWord64 s11 = s0 & 0x00000000000000ffULL;
const SWord8  s12 = table0[s11];
const SWord64 s14 = s0 >> 8;
const SWord64 s15 = 0x00000000000000ffULL & s14;
const SWord8  s16 = table0[s15];
const SWord8  s17 = s12 + s16;
const SWord64 s18 = s14 >> 8;
const SWord64 s19 = 0x00000000000000ffULL & s18;
const SWord8  s20 = table0[s19];
const SWord8  s21 = s17 + s20;
const SWord64 s22 = s18 >> 8;
const SWord64 s23 = 0x00000000000000ffULL & s22;
const SWord8  s24 = table0[s23];
const SWord8  s25 = s21 + s24;
const SWord64 s26 = s22 >> 8;
const SWord64 s27 = 0x00000000000000ffULL & s26;
const SWord8  s28 = table0[s27];
const SWord8  s29 = s25 + s28;
const SWord64 s30 = s26 >> 8;
const SWord64 s31 = 0x00000000000000ffULL & s30;
const SWord8  s32 = table0[s31];
const SWord8  s33 = s29 + s32;
const SWord64 s34 = s30 >> 8;
const SWord64 s35 = 0x00000000000000ffULL & s34;
const SWord8  s36 = table0[s35];
const SWord8  s37 = s33 + s36;
const SWord64 s38 = s34 >> 8;
const SWord64 s39 = 0x00000000000000ffULL & s38;
const SWord8  s40 = table0[s39];
const SWord8  s41 = s37 + s40;

return s41;
}
== END: "popCount.c" ==================


text:
The Vietnam Education Foundation and the Digital Utility

Chia sẻ: Hgiang Hgiang | Ngày: | Loại File: PDF | Số trang:2

0
132
lượt xem
17

The Vietnam Education Foundation and the Digital Utility

Mô tả tài liệu

Benefiting from global economic integration is not easy. It means more than trading or even getting FDI. It means creating conditions so that local knowledge is attractive to higher value added activities that draw in high quality capital, technology and management. This inflow sparks further activity, faster growth, and acts as an inducement for young people to acquire ever-greater skills. How does one get started on this virtuous circle?

Chủ đề:

Bình luận(0)

Lưu

Nội dung Text: The Vietnam Education Foundation and the Digital Utility

1. Fulbright Economics Teaching Program Technology & Development Vietnam Education Foundation and the Digital Utility The Vietnam Education Foundation and the Digital Utility David Dapice Benefiting from global economic integration is not easy. It means more than trading or even getting FDI. It means creating conditions so that local knowledge is attractive to higher value added activities that draw in high quality capital, technology and management. This inflow sparks further activity, faster growth, and acts as an inducement for young people to acquire ever-greater skills. How does one get started on this virtuous circle? One sure way is to train large numbers of people in science and technology. In Vietnam, the Soviet Union provided quite good scientific training at the graduate level, but that meant that higher-level education within Vietnam did not develop so much. Also, the Soviet model of separating research in institutes from education in universities has proven somewhat less productive than mixing them. After the collapse of the Soviet Union, there was a distinct decline in the level of scientific training for Vietnamese scientists and engineers. At the same time, budget cutbacks meant many institutes had to become self- supporting. This often meant doing applied services, or even leaving science altogether. A number of surveys in the 1990’s concluded that science education and research in Vietnam was slipping and badly needed to renovate itself.1 Many initiatives are underway but one of special interest is the Vietnam Education Foundation. This is a US foundation established by the US Congress and announced by President Clinton on his visit to Vietnam.2 President Bush has appointed its Board of Directors and it is just starting its activities. It is charged with promoting science and technology (S&T) in Vietnam, primarily through providing scholarships for Vietnamese who have been accepted to graduate S&T programs in the US, but also by running special one-year programs in both Hanoi and HCMC to prepare young Vietnamese scientists for graduate studies in the US. These programs would make use of US scientists who would teach and advise on curriculum development. Initial funding for 15 years is about $5 million a year.3 It may be augmented if there are more qualified applicants, with funds from both public and private sources likely. Part of the hope of the VEF is the hope that the curricular investments made in the preparatory programs will also help improve the teaching of science throughout Vietnam in all of the universities. To accomplish this, there are a number of other related initiatives also aiming to upgrade overall S&T. One, the Millennium Science Initiative, helps select developing nations to create new science research groups that are well tied into global knowledge networks and run by scientists in a lean and productive manner. Rather than 1 See, for example, “Science, Technology and Industry Strategy for Vietnam,” UNDP, 2001. 2 The source of these funds is payment of debt owed to the US by Vietnam. It came from the 1995 normalization of relations. Vietnam got the foreign exchange assets of the old regime in exchange for agreeing to make the (smaller value of) payments on the old regime’s civilian debt. Many Americans argued that this exchange, while normal legal practice, lacked historical sensitivity. 3 This amount can support a surprising number of graduate students since after the first year, many S&T graduate programs support their students from university resources, freeing the VEF to support more first year Vietnamese. Perhaps 100 per year could be supported from current levels of funding. David Dapice 1 2. Fulbright Economics Teaching Program Technology & Development Vietnam Education Foundation and the Digital Utility have a large permanent staff, there is a small core group and a large number of young, bright scientists rotated through. The hope is they will find ways to apply for interesting research funding and return to their home institutions and improve the level of teaching and research. Vietnam is currently in line to be a MSI member. However, another initiative has even wider implications. This is called the “Digital Utility.” The fact is that good research requires good libraries and access to huge amounts of information that is complete and up to date. Very few developing nations have invested enough to provide this for their scientists, much less students. In response, a number of foundations and other groups have suggested an alternative. Why not develop an electronic library that provides this access? Furthermore, why not include in this library not just books and journals, but also entire classes? The Massachusetts Institute of Technology has begun listing all of its classes – lecture notes, readings, problem sets, and tests. Anyone wanting it can get it through the Internet, for free. If, in addition, lectures of excellent teachers or researchers were also on-line (they are now available on videotape in entire courses for hundreds of dollars), then many poorly budgeted universities could upgrade both their teaching and that part of research that required information more than expensive instrumentation. This pattern need not be restricted to science either. If the copyright and technical issues can be overcome, there would be a huge jump in the availability of knowledge to anyone with an Internet connection. The name “Digital Utility” comes from the new conception of information. Like electricity, it could be turned on and provided to whomever wanted it, cheaply and immediately. Rapid drops in the price of electronic storage, wireless broadband (high speed Internet), computer chips and fiber optics will make the economics of the digital utility attractive even in poor nations. (Some computers are now being sold for$200 in US discount stores!) The low price of Internet Cafes in Vietnam already suggest approaches that would work for their universities, especially as regulation improves and existing technologies are more widely applied. If the MSI and preparatory programs put all of their research, lectures and curricula on-line, this would be a huge boost to all Vietnamese universities. Ultimately, these other universities may themselves contribute both research and classes to the general pool of knowledge. There are many stumbling blocks. Aside from working out payment protocols for recent scientific journals, there is the issue of language. Vast amounts of materials are published in English and they cannot all be translated. Until most scientists are bilingual, if indeed this happens, the question is how to help them access material not in their own language. One possibility is machine translation. This does not currently work very well, but is getting better, especially at narrow subjects where a learning algorithm is built into the software. (As human corrections are made to the raw “machine” translation, the software incorporates them into future machine translations.) Alternatively, language students with some science knowledge may be asked to translate summaries of the articles in return for scholarships. This would be a good incentive for more people to learn English! If the Digital Utility is developed in Vietnam, it could jumpstart the renovation of many universities and both education and research. By extending opportunities to so many, the likelihood that both domestic and foreign investment related to knowledge industries will find Vietnam attractive is greatly increased. This is illustrative of the kinds of investments needed to succeed at global economic integration. David Dapice 2


text:
Skip to main content

## Comments

1 comment

• Gurobi Staff

The syntax you are using is very reasonable, but unfortunately the expression y*y, which I would interpret as a quadratic expression of shape (5,), is not yet supported by gurobipy (all quadratic expressions must evaluate to a scalar). Extending this initial step towards a matrix friendly API taken in version 9.0 to include more general expressions is on the roadmap.

For now you can resort to the scalar level in your example, i.e.,

import gurobipy as gpimport numpy as npm = gp.Model("model")x = m.addMVar(shape=(10), name="x")y = m.addMVar(shape=(5), name="y")A = np.random.rand(5, 10)m.addConstrs((A[i,:] @ x - (y[i]@y[i]) <= A[i,0] for i in range(5)),name="const")m.setObjective(x.sum() - y @ y, gp.GRB.MAXIMIZE)

It's a bit more cumbersome but it should work.

Please sign in to leave a comment.


text:
# Direct Current Transmission Heating Problem

Direct Current Transmission Heating Problem
State dimension: $|A|$
Differential states: $2 |A| + |P|$
Discrete control functions: 0
Interior point equalities: 3

The direct current transmission heating problem models a simplified flow of direct electrical current within an electrical network with defined producers and consumers of electrical power. The model includes heating and cooling that occurs in electrical conductors due to specific resistance and heat exchange with the surrounding air. The goal is finding an optimal strategy for regulating the power production of individual producers as well as voltages and currents on specific conductors while minimizing the net power loss due to heating on all power lines over a fixed time horizon while fully supplying all consumers.

The model is largely assembled from well-known basic descriptions of phenomena easily accessible to the audience of high-school level physics courses. Mainly, these are Ohm's law, electrical resistivity, Joule heating and thermal conductivity. Note that changes of resistivity with respect to conductor temperature are taken into account.

## Physical background

The aim of the controller in this model is to provide all consumers with their required amount of electric power. Electric power is given by the product of voltage and current $P = I \cdot U$. The electric power is brought to the consumers from producers via a network of power lines. Producers are assumed to have the capability of accurately regulating their power output within a certain range. Power lines are assumed to be solid blocks of an electrically conductive material surrounded by a layer of insulating material. Their cross-section is assumed to be constant along the entire length of the power line. Since both heating and power loss increase with current but not with voltage, it is always preferable to transfer direct current at the highest possible voltage which is allowed by the design of the power line. Therefore, only the electrical current is considered as a control.

The power loss in a power line is given by $W = I^2 \cdot R$ where $R$ is the resistance of the power line which is derived from the resistivity of the conductor using the formula

$R = \rho \cdot \frac{l}{A}$

where $\rho$ is the resistivity of the conductor, $l$ is the length of the conductor and $A$ is the the cross-sectional area of the conducting material within the power line. Resistivity is assumed to vary exponentially with the temperature of the conducting material, meaning that $\rho = \rho_0 \cdot e^{\alpha T}$ where $\rho_0$ is the resistivity of the conducting material at room temperature (which is defined as $T = 0$) and $\alpha$ is a material-specific dimensionless constant. This causes a steady power loss of

$P_1 = \rho_0 \cdot e^{\alpha T} \cdot \frac{l}{A} \cdot I^2.$

The lost energy is transformed into heat which raises the temperature of the conductor. As the conductor is now hotter than the air surrounding its layer of insulating material, heat is steadily lost at a rate determined by the temperature difference, the conductors surface area and the insulating material's heat conductivity. The heat loss is given by

$P_2 = q \cdot S \cdot \Delta T$

where $q$ is the ratio between the isolating material's thermal conductivity and its thickness, $S$ is the surface area of the power line and $\Delta T$ is the difference between the conductor's temperature and the surrounding air's temperature (which we will assume to be the same as room temperature, i.e. $T = 0$). In summary, the rate at which the heat stored in a power line changes is given by

$\dot{W} = P_1 - P_2 = \rho_0 \cdot e^{\alpha T} \cdot \frac{l}{A} \cdot I^2 - q \cdot l \cdot C \cdot T$

where $C$ is the circumference of the cross-section of the power line. Assuming constant density, we can use the conducting material's volume-specific heat capacity, which we will refer to as $c$, to calculate the change in temperature from the change in heat:

$\dot{T} = \frac{\dot{W}}{c \cdot A \cdot l} = \frac{\rho_0}{c \cdot A^2} \cdot e^{\alpha T} \cdot I^2 - \frac{q \cdot C}{c \cdot A} \cdot T =: \beta_1 \cdot e^{\alpha T} \cdot I^2 - \beta_2 \cdot T.$

For the examples in this article, we will assume the conductor to be solid copper surrounded by a layer of cross-linked polyethylene (PEX) with a thermal conductivity of approximately $0.51 \; W / (m \cdot K)$.

## Mathematical formulation

Let $G = (V, A)$ a directed graph with vertex set $V$ and arc set $A$. Let $P, C \subset V$ be disjoint subsets of the vertex set. $P$ serves as the set of producer nodes while $C$ serves as the set of consumers. For $c \in C$ let $d_c$ denote the power demand for $c$. For $v \in V \setminus C$, let $d_v = 0$.

The resulting optimal control problem is given by

$\begin{array}{llcll} \displaystyle \min_{T, I, u} & \int_{t_0}^{t_f} \sum_{a \in A} P_{1,a}(t) \,\mathrm{d} t \\[1.5ex] \mbox{s.t.} & \dot{T}_a & = & \beta_{1,a} \cdot e^{\alpha_a T_a} \cdot I_a^2 - \beta_{2,a} \cdot T_a \qquad & \forall a \in A, \\ & d_v & = & \sum_{a \in \delta^{in}(v)} (U_a \cdot I_{a} - P_1^a) - \sum_{a \in \delta^{out}(v)} (U_a \cdot I_a) \qquad & \forall v \in V \setminus P, \\ & -u_v & = & \sum_{a \in \delta^{in}(v)} (U_a \cdot I_{a} - P_1^a) - \sum_{a \in \delta^{out}(v)} (U_a \cdot I_a) \qquad & \forall v \in P, \\[1.5ex] & T_a(t_0) &=& 0.0 \qquad & \forall a \in A, \\ & I_a(t) &\in& [0, I_{max, a}] \qquad & \forall a \in A, t \in [t_0, t_f], \\ & T_a(t) &\in& [0, T_{max, a}] \qquad & \forall a \in A, t \in [t_0, t_f], \\ & u_v(t) &\in& [0, u_{max, v}] \qquad & \forall v \in P, t \in [t_0, t_f]. \end{array}$

The differential state $T_a$ describes the temperature of power line $a$ while the controls $I_a$ and $u_v$ represent the current in a power line $a \in A$ and the power produced in a production node $v \in P$ respectively.

## Parameters

There are multiple test scenarios. For all scenarios, we allow three types of conductors, all of which are copper ($\alpha = 0.003862$, $\rho_0 = 1.68 \cdot 10^{-8} \; \Omega m$, $c = 3.446 \cdot 10^9 \; J / (K \cdot m^3)$) cylinders surrounded by an insulating layer of PEX:

Type Voltage Conductor diameter Insulator thickness $A$ $C$ $q$
A $330 \;kV$ $7 \;cm$ $2 \;cm$ $0.003848 \;m^2$ $0.2199 \;m$ $25.5 \;W / (m^2 \cdot K)$
B $220 \;kV$ $5 \;cm$ $1.5 \;cm$ $0.001963 \;m^2$ $0.1571 \;m$ $34 \;W / (m^2 \cdot K)$
C $110 \;kV$ $3 \;cm$ $0.75 \;cm$ $0.0007069 \;m^2$ $0.09425 \;m$ $68 \;W / (m^2 \cdot K)$

PEX looses structural integrity at operating temperatures roughly in excess of $120^{\circ} C$ which means that $T_{max,a} = 100$ for all three types of power lines.

### Delayed heating

In this scenario, we consider a simple network consisting of two producers producing up to $1 \;MW$ each and a single consumer with a demand of $1.25 \;MW$. Both producers have direct power links of type C and length $1 \;km$ to the consumer. The time horizon is defined as $(t_0, t_f) = (0, 300)$. A JSON description of the network can be found under Direct Current Transmission Heating Problem: Delayed heating (Network).


text:
AL MEJOR ESTILO DE ALMA WOMEN BOUTIQUE!

## Reflexion Crack

Reflexion is a small (in size) application that alerts you when it is time for a pause.

Once you have started the application, you can set a start and stop time and a number of pauses. After each pause is scheduled, Reflexion will prompt you with a notification pop-up.
If, at any time you want, you can set a custom file with a sound for the notification.

The action of starting and stopping Reflexion is translated to a window service and is started automatically at system-start and put to sleep at system-shutdown.
Compatibility: Works on any version of Windows between XP and Vista.

Your comments are important to us and help us to make this software better.

Code:

Reflexion v1.0 for Win7 and Vista

The files are in Windows Installer Package format (WIP).
In Windows XP SP2 and below, you can select the Run option when opening the file.
To install, simply double click the.MSI file.
Double-click the.MSI file once to run the setup, then to perform the installations.
Click the Finish button to complete the installation.

Note: For Windows 7 and later, double-clicking the.MSI file will launch the MSI Installer which will go through the setup process and then launch Reflexion.

Misc Notes:

* You can start Reflexion manually from the Start menu.

* If the computer was shutdown since the last time Reflexion was run, Reflexion will use a skeleton pause definition file.
* You can check the custom pause definition file and modify its contents if you like.

* You can set the minimum pause time to 1 second, which causes Reflexion to execute very little processing and consume less CPU resources (for Windows Vista, 2000 and XP).
* You can set the maximum pause time to unlimited (infinite) and thus use no CPU resources.
* You can also set the pause time to be fixed.

* The default pause time is set to 15 seconds.

* You can start Reflexion manually, if the computer was shut down since the last time Reflexion was run.

* You can also manually stop Reflexion if the computer was shut down since the last time Reflexion was run.

* You can select the custom file(s) to be played before you start Reflexion.

* If you

## Reflexion Crack +

* Covers most of the OSX functionality
* Tracks time spend on programming/debugging per program
* Toggle between time and CPU usage
* Works without administrator permissions (disabled by default)
* Plugin support – more to come
* Easy to use
* 1.0
* Maintained by [QU-HE](

Reflexion features:
* Stop time
* Start time
* CPU usage
* Time
* Reset time
* Preselect time:
1.00:00
2.00:00
3.00:00
4.00:00
5.00:00
6.00:00
7.00:00
8.00:00
9.00:00
10.00:00
11.00:00
12.00:00
13.00:00
14.00:00
15.00:00
16.00:00
17.00:00
18.00:00
19.00:00
20.00:00
21.00:00
22.00:00
23.00:00
24.00:00
25.00:00
26.00:00
27.00:00
28.00:00
29.00:00
30.00:00
31.00:00
32.00:00
33.00:00
34.00:00
35.00:00
36.00:00
37.00:00
38.00:00
39.00:00
40.00:00
41.00:00
42.00:00
43.00:00
44.00:00
45.00:00
46.00:00
47.00:00
48.00:00
49.00:00
50.00:00
51.00:00
52.00:00
53.00:00
54.00:00
55.00:00
09e8f5149f

## Reflexion Crack [Win/Mac]

—————————
Reflexion is a simple application designed to help programmers take a proper break. When it is time to take a break, Reflexion will ask your and politely inform you that it is time to pause. Of course in a civilized world a pause should be taken at a regular intervals.
When the pause is complete, Reflexion displays a list of all pauses. The audio file option allow you to play a sound to prelude the pause.
You can also set a min and a max pause times and the app will update itself accordingly.

Changes in 1.1
—————

* Release number updated.
* Audio playing can now choose between a sound file, an MP3 or a WMA file.
* A new option “Wait for X seconds before asking again” has been added.

Changes in 1.0
—————

* Initial release

Legal Issues
————–

Reflexion is freeware, but redistribution of Reflexion is not allowed.
Mick Young (Australian footballer)

Michael David “Mick” Young is a former Australian rules footballer who played for the Sydney Swans in the Victorian Football League (VFL).

Young was recruited from the Lakeside Football Club in the Castlemaine Football League, and made his debut in Round 14 of the 1967 VFL season. His final game was in Round 3 of the 1968 season.

He represented Victoria at the 1968 Hobart Carnival and 1970 Brisbane Carnival.

Notes

Category:1946 births
Category:Living people
Category:Sydney Swans players
Category:Australian rules footballers from Victoria (Australia)
Category:Castlemaine Football Club playersQ:

$\sum\limits_{n=1}^{\infty} \frac{x}{n} + \sum\limits_{n=1}^{\infty} \frac{x^2}{n} + \sum\limits_{n=1}^{\infty} \frac{x^3}{n} + \cdots$

I want to know if the following function satisfies the Cauchy product test.
f(x)= \sum\limits_{n=1}^{\infty} \frac{x}{n} + \sum\limits_{n=1}^{\infty} \frac{x^2}{n} + \sum

## What’s New In Reflexion?

Reflexion is a small utility for Windows users to help remind us of the need to take a break. Each time the program will prompt us with a sound to remind you of the time and let you know that it’s time to take a break.
The program will keep track of the number of times you have pressed the “Start” button and it will keep track of the number of minutes you have spent working. If you are into serious programming you can set the time when the computer should stop working.
The program is 100% GPL and free. It is a real timesaver, and a valuable reminder.

LispNewbies is an introductory tutorial for Lisp written by Frank
Lang. LispNewbies is similar to the Beginner’s Tutorials series, but
it assumes a more experienced reader than in the BT series. It uses
practical examples and is more Lispy than the BT tutorials.

The first few chapters contain an overview of Lisp and how to
program using the stack based approach. The rest of the book is
devoted to the topic of Lisp.

The book opens with a discussion of a few programming constructs
such as the stack and the symbols.

Chapter 2 introduces Scheme, a subset of Lisp. This chapter is
intended to give the reader a good understanding of Scheme, which
can be used as a way to learn Lisp, and to familiarize the reader
with the kinds of things that might exist in a minimal Lisp system.

Chapter 3 describes the operating system primitives and the general
concept of a Lisp operating system.

Chapter 4 introduces Lisp, a general purpose programming language.
It reviews the structure of Lisp programs and presents enough
definitions to implement them.

Chapter 5 introduces the Lisp interpreter. It is important to
understand the concepts of evaluating Lisp programs in order to
fully understand how the Lisp interpreter works.

Chapter 6 covers the built-in procedures in a Lisp system. The
first six chapters include the essential information required to
get up and running in a Lisp environment.

Chapter 7 introduces InterLisp, a proprietary Scheme implementation
developed at MIT by Guy Steele. It serves as an excellent
introductory example for the writing of an interpreter for a
Scheme-like language.

Chapter 8 covers Lisp Machine Lisp, an extension of Lisp that
describes how Lisp machines can operate. It also introduces the
Notation, one of the most useful constructs


text:
Comment
Share
Q)

# The name wonder metal is given to

$(a)\;Platinium \\(b)\;Diamond \\(c)\; Titanium \\(d)\;Gold$

Comment
A)
Because it is very hard, very high , high melting point.
Hence c is the correct answer.


text:
Contents

Contents

Idea

…a regular polytope

… the higher dimensional analog of a regular polyhedron


text:
# State the sine law formula?

State the sine law formula?

• Questions are typically answered in as fast as 30 minutes

### Plainmath recommends

• Get a detailed answer even on the hardest topics.
• Ask an expert for a step-by-step guidance to learn to do it yourself.

Jennifer Hill
Step 1
Sine Law:
It is the relationship between the angles and the sides of the non-right triangles.
Since,we have a triangle:

Sine Law for finding sides:
$$\displaystyle{\frac{{{a}}}{{{\sin{{\left({A}\right)}}}}}}={\frac{{{b}}}{{{\sin{{\left({B}\right)}}}}}}={\frac{{{c}}}{{{\sin{{\left({C}\right)}}}}}}$$
Sine Law for finding angles:
$$\displaystyle{\frac{{{\sin{{\left({A}\right)}}}}}{{{a}}}}={\frac{{{\sin{{\left({B}\right)}}}}}{{{b}}}}={\frac{{{\sin{{\left({C}\right)}}}}}{{{c}}}}$$