text:
# Revision History¶

A running log of all changes that are made to this API with each iteration.

## Version 2.0¶

Many things... Documentation coming.

## Version 1.2¶

V1.2 makes versioning the python much simpler. It allows for much easier modification to the PiSoC firmware, without needing to version those changes in the python code. It also simplifies the API expansion process greatly for new developers, and provides frameworks for easy integration of new interfaces.

### New to v1.2.7¶

• Changed all references of RPiSoC to PiSoC in the Python API and the documentation to be consistent with the official branding.

### New to v1.2.5¶

In PiSoC code:

• Changed tuning method of CapSense CSD component from SmartSense to None. Tuning is now handled manually.
• Without SmartSense analog.CapSense.Read() does not behave correctly, and so it will likely become deprecated
• Updated project to use PSoC Creator 3.1

• Added analog.CapSense.readRaw() for reading raw data form the CapSense buffer, to be used for manual calibration
• Added analog.CapSense.isTouched() to replace analog.CapSense.Read() for when SmartSense is disabled (it is by default)
• Added calibration code to analog.CapSense.Start() so that analog.CapSense.isTouched() gives desired behavior without SmartSense

In pisoc.SERIAL

• Changed the initialization so that a serial port does not need to be provided. It will be determined at run time, and should be platform independent.
• Added pisoc.SERIAL.reconnect() for situations where the PiSoC might lose connection, and the user can check for this and reconnect if needed
• Added pisoc.SERIAL.disconnect() for a clean closing of the serial port
• Added pisoc.SERIAL.isConnected() to check the status of the serial connection with the PiSoC

### New to v1.2.4¶

In the PiSoC code

• Added support for a standard Ultrasonic Range Finder, which should be useable by any SR-series range finer, excluding the 08 (which uses a different protocol), and the 3-pin Parallax ranger.
• Generally, it will support any range finder that uses a GPIO protocol based on pulse length measurements.
• This includes both 3-pin, 4-pin, and 5-pin devices
• Trigger length, and timeout duration is set on the application layer, so it can be as transportable as possible
• It was originally implemented using a hardware timer capturing clock events between the rising and falling edge of an input pin, but it required the use of customized digital logic and cascaded hardware multiplexers to handle the routing of any GPIO to the Timers input.
• At full scale, this used more digital resources than was acceptable, and so it was abandoned for a software approach
• The timer component is still used for accuracy purposes, but it is used in its fixed function state, so that no UDB resources are wasted, and the routing was handled in software

• Added digital.rangeFinder with the following supported methods:
• digital.rangeFinder.readRaw(): gets a raw value from the PiSoC, which is representative of how many microseconds the rangers echo pin was held high. It will trigger the range by sending a short pulse, the length defined upon construction of the object. The result will be measured on the desired signal pin, and stop measuring when a timeout is reached
• digital.rangeFinder.readMeters(): Uses readRaw to get a raw time value in microseconds, and then calculates the distance between the ranger and the pinged object in meters
• digital.rangeFinder.readCentimeters(): Uses readRaw to get a raw time value in microseconds, and then calculates the distance between the ranger and the pinged object in centimeters
• digital.rangeFinder.readInches(): Uses readRaw to get a raw time value, and then calculates the distance between the ranger and the pinged object in Inches
• digital.rangeFinder.setDelay(): Sets the length of the trigger pulse, in microseconds, which will be used to tell the device to send out a ping. This is handled in __init__, so it should only be called under unique circumstances.
• digital.rangeFinder.setTimeout(): Sets the timeout length in microseconds. If the PiSoC is still waiting for a completed response after this amount of time, it will stop counting and immediately return the result. This is handled in __init__, so it should only be called under unique circumstances.

### New to v1.2.3¶

In the PiSoC code

• Included custom component for NeoPixel (or general WS2812 strip light) control. Output is on Port 6, pin 0 (required by the shield).
• This means that the first PWM output, which was on P6[0], had to be moved to Port 0 Pin 2
• Added digital.NeoPixelShield which supports use of the NeoPixels Arduino shield through Python. Included methods are:
• digital.NeoPixelShield.Start(): Powers up and enables the needed hardware for the NeoPixels component
• digital.NeoPixelShield.Stop() : Powers down and disables the hardware used by the NeoPixels component
• digital.NeoPixelShield.Stripe(): Draws a line of length len of the stated color, starting from the first pixel, and extending as far as the 40th (last) pixel. It will wrap around rows
• digital.NeoPixelShield.SetPixel(): Sets a pixel of the stated color at position (x,y) = (row, column)
• digital.NeoPixelShield.DrawRow(): Fully draws the chosen row the desired color
• digital.NeoPixelShield.DrawColumn(): Fully draws the chosen column the desired color
• digital.NeoPixelShield.Dim(): Preserves the color to be drawn to the shield, but dims the brightness.
• Added 140 predefined colors as class attributes. They are the standardized colors of the HTML and CSS interfaces, and they are called by their official names, so for an object constructed as ‘shield’, you could access the color black with shield.Black

### New to v1.2.2¶

In the PiSoC code

• USBUART (Serial) support has been added, allowing for use of the board through PC interfaces
• Added class SERIAL() which will open a Windows COM Port, or Linux or OS X Serial Port for communication with the PiSoC over any baud rate
• It is chosen from the application layer by:
PiSoC(port)

### New to v1.2.1¶

This was a largely structural change to the PiSoC firmware. It redesigned the data structures in place for handling of device requests.

• A bit-field struct is now used as the global data vessel, which will contain all needed data for any request made

• An additional layer of abstraction was added to the firmware, which should simplify the process of expansion for new developers
• Functions that make calls to hardware registers no longer handle any data packing- they all require meaningful, unpacked data as arguments
• The new abstraction layer handles bit unpacking, and then repacking into the bit-field for any supported device
• This bit-field, which should contain all relevant data, is then passed to the hardware layer where all arguments will be derived directly from an attribute of the struct
• Parallel work done by Mark Bradley has been merged with my work for LabVIEW support through a LINX bridge

### New to v1.2.0¶

In the PiSoC code:

• Added a way for the PiSoC to scan its generated source to determine
• What GPIO were being used
• How many PWMs, analog pins, and capsense buttons are being used
• If there existed one or more VDACs, IDACs, Delsig ADCs, SAR ADCs, or Wave DACs
• The full scale ranges on any DACs that are found
• The resolution of every PWM being used, as well as how many unique clocks are driving them
• Details about exactly which PWMs are sharing specific clocks, and the source frequency and default divider placed on those clocks
• That data was then packed appropriately so that it could easily and efficiently be sent to the Raspberry Pi on request

• Changed the GPIO structure to support all possible GPIO, and removed the control/status registers which were previously writing to, and polling these GPIO. With this approach, modification is simplified and digital resources are reserved.

• Added full support for up to 24 PWM channels (previously there was only support for 8)

• Added support for 6 CapSense buttons, located on Port 4, pins 0-5, with P4[6] needing a ~2.2nF Cmod

• Made a skeleton for UART support, but haven’t yet completed the implementation

In pisoc.PiSoC:

• Added the ability to determine what is in the PiSoC firmare during the construction of the object.
• Added a DEBUG feature, which when set to True will print warnings and other diagnostic information to the terminal during run time
• Fixed a bug which caused errors with 8-bit PWMs, due to a poorly derived (non-generalized) formula for calculation of a comparison value

In all classes

• Removed hard coded constraints, dependent on the version of the API, and replaced them with references to the data collected at construction of the PiSoC object.
• For instance, instead of raising an exception when you ask to initialize an analog pin not in range(10), as it was previously, I will raise an exception when trying to initialize an analog pin not in range(PiSoC.ANALOG_IN_NUM), where PiSoC.ANALOG_IN_NUM is the number of analog inputs which were discovered when the PiSoC class was constructed. This makes the API more portable and easier to version.

In pisoc.SPI and pisoc.I2C

• Provided an optional second argument to the receiveData() method, which will accept a delay, in seconds, to be called between the write operation and read operation. This is to be used by advanced users expanding the API. If a feature they implement requires a highly complex operation to be executed on the PiSoC, the Python may have to wait a small amount of time between the request and the response. Otherwise, a garbage response will be returned by the method.

## Version 1.1¶

This version provides the Pi with a lot more functionality, and use of the API is intended to be more flexible than in the previous version.

### New to v1.1.2¶

In the PiSoC code

• Removed the second SAR ADC and replaced it with a sequenced ADC, with 10 analog inputs. This allows for simplified use of analog pins, and gives 10 more.
• Removed Port 6 as a GPIO register so that more analog pins could be added
• PWM (and consequently servo) pins were moved from Port 3 to Port 6, so that Port 3 could be used for the new analog pins (Ports 0 and 3 have slightly better analog performance than the other ports)
• Changed the structure of the GPIO functionality enumeration. I concatenated all of the seperate GPIO registers into one register, and changed the packing and unpacking process of each transfer to contain the port, pin, command, and value to be written if applicable.
• Added the ability to change drive modes to each GPIO at run time.
• Fixed the import structure so that both smbus and spidev aren’t needed. This means you don’t have to configure the Pi for I2C if you only intend to use SPI, or vice versa.
• Removed classes digital.DigitalInput and digital.DigitalOutput
• Added class digital.digitalPin which allows one to instantiate any of the GPIO as input or output, or in any of several different drive modes if needed.
• Simplified instantiation. It is now only required to provide a servo location relative to Port 6.
• Pulse width and angle ranges can still be input, but they will simply default to standard values if only the servo location is given
• Minimum pulse width defaults to 1.0; maximum pulse width defaults to 2.0; minimum angle defaults to 0; maximum angle defaults to 180

### New to V1.1.1¶

Code structure

• communication.py was removed and merged with module pisoc.py to simplify the overall structure.

In pisoc.SPI

• Further minimized latency inherent to each SPI transfer.
• pisoc.SPI.cleanup() will now reset any global data tracked within the PiSoC class, in case pisoc.SPI.cleanup() is not called at termination
• pisoc.I2C.cleanup() method will now reset any global data tracked within the PiSoC class, in case pisoc.I2C.cleanup() is not called at termination
• Added analog.VDAC.SetVoltage() method, so that the user can directly input a voltage within the specified DAC’s full scale range
• Added a analog.IDAC.SetCurrent() method, so that the user can directly input a current in milliamperes within the specified DAC’s full scale range

### New to V1.1.0¶

In the PiSoC code

• Added the ability to software reset the PiSoC through the Raspberry Pi
• Removed unneeded delays, speeding up the init process
• changed which bootloader is used
• clocked the PWM’s seperately, such that they aren’t all sharing the same clock; they are only sharing their clock with one other PWM instead of 7, as was the case in V1.0.0
• Fixed a bug discovered in the WaveDAC class, which was generating waves that appeared to be very noisy.
• Added ability to modify the frequency of the clocks which drive the PWM signals with digital.PWM.SetClocks()
• Added ability to read back the actual PWM clocking frequency with digital.PWM.GetClocks()
• Added a warning when the clock range of the PWM clocks might be inaccurate (since the frequencies are generated using clock dividers, and they can be inaccurate at high frequencies)
• Changed digital.PWM.SetDutyCycle() to be a float value instead of an int, for more precision
• Added digital.PWM.GetDutyCycle() which will give back the percentage of time between 0 and 100 how long your PWM is high.
• Added digital.PWM.SetClockDivider() which lets you give the PWM clock a specific divider value, so you don’t have to be worried about an inaccurate result using digital.PWM.SetClocks()
• Added digital.PWM.GetClockDivder() method to see what the most recently confirmed clock divider value is
• Added digital.PWM.SetFrequency() which provides the ability to modify the actual wave frequency of the PWM, between 0.006 Hz and 2.4MHz, without affecting the duty cycle too profoundly.
• Added digital.PWM.GetFrequency() method which will return the actual frequency of the PWM wave
• Added class attributes to the PiSoC indicate whether a register address is already in use. So if the user attempts to initialize an object that is already in use, a warning will be issued.
• Changed return value of analog.ADC.CountsTo_Volts() from a millivolt value to a microvolt value, so that precision is increased. The return value of the Python method when called is still in Volts.

In classes digital.DigitalInput and digital.DigitalOutput

• Moved the bit masking process of the digital inputs and outputs to the C code, where it can be executed more quickly, and with fewer data transfers
• Added a warning when the frequency might be out of range

## Version 1.0¶

The public release of the API. It exposes, most fundamentally, the following functionality to the Raspberry Pi through the PiSoC

• 8 PWM channels
• 20 digital outputs
• 19 digital inputs
• 2 8-bit VDAC’s
• 1 8-bit IDAC
• 1 8-bit WaveDAC
• 1 16-bit Delta Sigma ADC

Communication to the PiSoC requires use of SPI. No other communication protocol is yet supported, and the VDAC’s and IDAC’s are currently untested.


text:
# zbMATH — the first resource for mathematics

Connective constant for a weighted self-avoiding walk on $$\mathbb{Z}^2$$. (English) Zbl 1326.82012
Summary: We consider a self-avoiding walk on the dual $$\mathbb{Z}^2$$ lattice. This walk can traverse the same square twice but cannot cross the same edge more than once. The weight of each square visited by the walk depends on the way the walk passes through it and the weight of the whole walk is calculated as a product of these weights. We consider a family of critical weights parametrized by angle $$\theta\in[\frac{\pi}{3},\frac{2\pi}{3}]$$. For $$\theta=\frac{\pi}{3}$$, this can be mapped to the self-avoiding walk on the honeycomb lattice. The connective constant in this case was proved to be equal to $$\sqrt{2+\sqrt{2}}$$ by H. Duminil-Copin and S. Smirnov [Ann. Math. (2) 175, No. 3, 1653–1665 (2012; Zbl 1253.82012)]. We generalize their result.

##### MSC:
 82B41 Random walks, random surfaces, lattice animals, etc. in equilibrium statistical mechanics 60J67 Stochastic (Schramm-)Loewner evolution (SLE) 60K35 Interacting random processes; statistical mechanics type models; percolation theory 82D60 Statistical mechanics of polymers
Full Text:

format: plain


text:
The discrete moment problem with nonconvex shape constraints.(English)Zbl 1470.90060

Summary: The discrete moment problem is a foundational problem in distribution-free robust optimization, where the goal is to find a worst-case distribution that satisfies a given set of moments. This paper studies the discrete moment problems with additional shape constraints that guarantee the worst-case distribution is either log-concave (LC), has an increasing failure rate (IFR), or increasing generalized failure rate (IGFR). These classes of shape constraints have not previously been studied in the literature, in part due to their inherent nonconvexities. Nonetheless, these classes are useful in practice, with applications in revenue management, reliability, and inventory control. We characterize the structure of optimal extreme point distributions under these constraints. We show, for example, that an optimal extreme point solution to a moment problem with $$m$$ moments and LC shape constraints is piecewise geometric with at most $$m$$ pieces. This optimality structure allows us to design an exact algorithm for computing optimal solutions in a low-dimensional space of parameters. We also leverage this structure to study a robust newsvendor problem with shape constraints and compute optimal solutions.
The e-companion is available at https://doi.org/10.1287/opre.2020.1990.

MSC:

 90C17 Robustness in mathematical programming

Software:

ROME; logcondiscr
Full Text:


text:
1. Elementary row operation

Let
$e$ be an elementary row operation,
$A,B,C$ be a $n \times n$ matrices
By $e(A)$ we mean the resultant matrix after we perform $e$ on $A$

Does the the following hold true -
$e(A)B = Ae(B)$ ?

Also, we know the $e(A)=e(I_n)A$. One way to prove this is for each kind of elementary row operation establish this fact by performing the computation on the matrix elements.

I was wondering if there is a more conceptual/abstract argument, logic, reason behind this to work.

Thanks

2. Originally Posted by aman_cc
Let
$e$ be an elementary row operation,
$A,B,C$ be a $n \times n$ matrices
By $e(A)$ we mean the resultant matrix after we perform $e$ on $A$

Does the the following hold true -
$e(A)B = Ae(B)$ ?
no! for example in $M_n(\mathbb{C}),$ choose $e=e_{11} + 2e_{22}, \ A=e_{12}, \ B=e_{21}.$ then: $(eA)B=e_{11} \neq 2e_{11}=A(eB).$

3. Originally Posted by NonCommAlg
no! for example in $M_n(\mathbb{C}),$ choose $e=e_{11} + 2e_{22}, \ A=e_{12}, \ B=e_{21}.$ then: $(eA)B=e_{11} \neq 2e_{11}=A(eB).$
Thanks NonCommAlg.

Though I am fairly confident of the following still would check this:
if $C=AB$ then $e(C) = e(A)B$

Also is there another conceptual-argument (based on linear transformation etc) for $e(A)=e(I_n)A$ to be true? The proof I have at my disposal is based on actual computation.

4. Originally Posted by aman_cc
Thanks NonCommAlg.

Though I am fairly confident of the following still would check this:
if $C=AB$ then $e(C) = e(A)B$
this is true because, (at least) over a field, "matrix multiplication" is associative. so $e(AB)=(eA)B.$ you're making your job hard by looking at $e$ as a map rather than just a matrix.

Also is there another conceptual-argument (based on linear transformation etc) for $e(A)=e(I_n)A$ to be true? The proof I have at my disposal is based on actual computation.
i don't know what kind of "concept" or even "computation" you're talking about here? $I_n$ is the identity matrix and so $eI_n=e,$ which gives us $e(I_n)A=(eI_n)A=eA=e(A).$

5. Originally Posted by NonCommAlg
i don't know what kind of "concept" or even "computation" you're talking about here? $I_n$ is the identity matrix and so $eI_n=e,$ which gives us $e(I_n)A=(eI_n)A=eA=e(A).$
Thanks for confirming the part (1). After you said it - I realized I was asking a very trivial question.

For part(2) - Let me try to explain.
When I say 'e' is an elementary row operation. I look at it as some kind of a function on A. e(A) in my way of thinking is image of A under e.

Now it so happens that $e(A) = e.A$
In R.H.S. I guess $e$ is treated like a matrix ( $e=e(I_n)$). And, $e.A$ is a matrix multiplication.

I guess it is this multiplication that you refer when you write $eI_n=e$

My question is why should $e(A) = e.A$? Is there a logic to it - or this is a fact which just happens to be true based on how we define
1. Elementary Row Operation
2. Matrix Multiplication

Please ignore this question if it is really not relevant. Maybe I need to get more clear in my head.

6. Originally Posted by aman_cc

My question is why should $e(A) = e.A$? Is there a logic to it - or this is a fact which just happens to be true based on how we define
1. Elementary Row Operation
2. Matrix Multiplication
well, the only way to prove that is direct calculation, i.e. to check that $eA$ really does the required row operation.

here's a question for you to think about: can you write an elementary matrix in terms of $e_{ij}$?

( $e_{ij},$ as usual, is the square matrix with 1 in the $i$-th row and $j$-th column and 0 everywhere else)

7. Originally Posted by NonCommAlg
well, the only way to prove that is direct calculation, i.e. to check that $eA$ really does the required row operation.

here's a question for you to think about: can you write an elementary matrix in terms of $e_{ij}$?

( $e_{ij},$ as usual, is the square matrix with 1 in the $i$-th row and $j$-th column and 0 everywhere else)

Let me try

$I_n = \sum e_{ii}$ , where $i \in [1,n]$
In the equations below I have used the above mentioned expansion.

Interchange of row - $Row_a \leftrightharpoons Row_b$
$e = I_n - e_{aa} - e_{bb} + e_{ab} + e_{ba}$

Multiplication by a scalar $Row_a = x \times Row_a$
$e = I_n - e_{aa} + x \times e_{aa}$

Adding a scalar multiple of a row to another row $Row_a = Row_a + x \times Row_b$
$e = I_n + x \times e_{ab}$

Am I anywhere close to what you wanted me to try? If yes, any specific importance of this method?

Thanks very much !!

8. Originally Posted by aman_cc
Let me try

$I_n = \sum e_{ii}$ , where $i \in [1,n]$
In the equations below I have used the above mentioned expansion.

Interchange of row - $Row_a \leftrightharpoons Row_b$
$e = I_n - e_{aa} - e_{bb} + e_{ab} + e_{ba}$

Multiplication by a scalar $Row_a = x \times Row_a$
$e = I_n - e_{aa} + x \times e_{aa}$

Adding a scalar multiple of a row to another row $Row_a = Row_a + x \times Row_b$
$e = I_n + x \times e_{ab}$

Am I anywhere close to what you wanted me to try? If yes, any specific importance of this method?

Thanks very much !!
right! of course, "multiplying by a scalar" and "adding a scalar multiple of a row to another row" have the same form, which is $I + ce_{ij}.$ so we basically have two distinct forms of matrices.

the reason that i gave you this question is that using these forms makes the proof $e(A)=eA$ easier. that's because we can write the matrix $A=[a_{ij}]$ in the form $A=\sum_{i,j}a_{ij}e_{ij}$ and then

we can use this fact that $e_{ij}e_{rs}=\delta_{jr}e_{is},$ where $\delta_{jr}$ is, as usual, the Kronecker's delta.

9. I get the idea. Thanks very much !!


text:
The refdb package is a reference database manager offering a set of powerful functions to import, organize, clean, filter, audit and export reference genetic data. It has been designed as an environment for semi-automatic and assisted construction of reference databases and to improve standardization and repeatability in metabarcoding studies.

## Installation

You can install the development version of refdb from GitHub.

remotes::install_github("fkeck/refdb")


text:
# PCNTX2

Bulk Data Entry Defines properties TYPE2 tied CONTACT interface for geometric nonlinear analysis.

## Format

(1) (2) (3) (4) (5) (6) (7) (8) (9) (10)
PCNTX2 PID
IGNORE FSPOT LEVEL ISRCH IDELG
If FSPOT = 20, 21, or 22, two continuation lines
(1) (2) (3) (4) (5) (6) (7) (8) (9) (10)
RUPT IFILT SRTID SNTID STTID   MAXND MAXTD
FSTR FSTRATE FDIST ALPHA
If FSPOT = 25, one continuation line
(1) (2) (3) (4) (5) (6) (7) (8) (9) (10)
STFAC VISC

## Example

(1) (2) (3) (4) (5) (6) (7) (8) (9) (10)
PCONT 34
PCNTX2 34

## Definitions

Field Contents SI Unit Example
PID Property identification number of the associated PCONT.

No default (Integer > 0)

IGNORE Flag to ignore secondary nodes if no main segment found for TIE contact. 6
0
No deletion of secondary nodes.
1
Secondary nodes with no main segment found are deleted from the interface.
2
Secondary nodes with no main segment found are deleted from the interface, if SRCHDIS is blank, then it would be new calculated internally.

Default as defined by CONTPRM (Integer)

FSPOT Spot weld formulation flag.
1
Formulation is optimized for spot weld or rivets.
2
Same formulation as standard formulation. Required when using hierarchy levels. Not compatible with nodal time step (TSTYP= GRID, TSC = CST).
4
Rotational degrees-of-freedom are not transmitted (if shells are used).
5 (Default)
Standard formulation.

(Integer)

20, 21, 22 - formulation with failure. Not compatible with nodal time step GRID(CST) on XSTEP card. The stress is computed for each secondary node according to the "equivalent" surface around the node. The equivalent surface is defined accordingly:
20
Surface computed using shell and brick faces attached to the node.
21
Surface computed using only the shell attached to the node.
22
Surface computed using only the brick faces attached to the node.
25
Penalty formulation.
30
Formulation with cubic curvature of main segment. Not compatible with nodal time step GRID(CST) on XSTEP card.

LEVEL Hierarchy level of the interface.

No default (Integer > 0)

ISRCH Search formulation flag for the closest main segment.
1
Old formulation (only used for previous version).
2 (Default)
New improved formulation.

(Integer)

IDELG Node deletion flag.
0
No deletion.
1
The kinematic condition is suppressed on secondary node, if the main element is deleted. (The secondary node is removed from the interface).

RUPT Failure model (only available with FSPOT = 20, 21, or 22) 6
0
Failure when MAXND or MAXTD are reached.
1
See Comment 10.

(Integer)

IFILT Filter flag. 12
0 (Default)
No filtering.
1
Filtering (alpha filter).

(Integer)

SRTID TABLEDi entry identification number defining stress factor versus stress rate. 8

No default (Integer ≥ 0)

SNTID TABLEDi entry identification number defining maximum normal stress versus normal relative displacement (ND).

This function must be defined. 8

No default (Integer > 0)

STTID TABLEDi entry identification number defining maximum tangential stress versus tangential relative displacement (TD).

This function must be defined. 8

No default (Integer > 0)

MAXND Maximum normal relative displacement.

Default = 1.0E20 (Real)

MAXTD Maximum tangential relative displacement.

Default = 1.0E20 (Real)

FSTR Stress scale factor. 8

Default = 1.00 (Real)

FSTRATE Stress rate scale factor. 8

Default = 1.00 (Real)

FDIST Distance scale factor. 8

Default = 1.00 (Real)

ALPHA Stress filter alpha value.

Default = 1.00 (Real)

STFAC Interface stiffness scale factor. (Only used with FSPOT = 25).

Default = 1.00 (Real)

VISC (Optional) Critical damping coefficient on interface stiffness (Only used with FSPOT = 25).

Default = 0.05 (Real)

1. The property identification number must be that of an existing PCONT Bulk Data Entry. Only one PCNTX2 property extension can be associated with a particular PCONT.
2. PCNTX2 is only applied in geometric nonlinear analysis subcases which are defined by ANALYSIS = EXPDYN. It is ignored for all other subcases.
3. PCNTX2 is only valid for tied contact specified using the TIE Bulk Data Entry. The PID field on the TIE entry can be used to reference the PCNTX2 entry.
4. Interface TYPE2 is a kinematic condition, no other kinematic condition should be set on any nodes of the secondary surface.
5. The default value for SRCHDIS is the average of the main segments.
6. If IGNORE = 1 or 2, the secondary nodes without a main segment found during the searching are deleted from the interface;

If IGNORE = 1 and SRCHDIS is blank, then the default value of the distance for searching closest main segment is the average size of the main segments;

If IGNORE = 2 and SRCHDIS is blank, then the distance for searching closest main segment is computed as follows for each secondary node:

d1 = 0.6 * (Ts + Tm)

d2 = 0.05 * Tmd

SRCHDIS = max(d1 , d2)

Where,
Ts
Thickness of the element connected to the secondary node, for solids Ts = 0.0
Tm
Thickness of main segment, for solids Tm = Element volume / Segment area
Tmd
Main segment diagonal
7. Main nodes of an interface TYPE2 may be secondary nodes of another interface TYPE2 if the hierarchy level of the first interface is lower than the hierarchy level of the second interface. Hierarchy levels are only available with FSPOT=2.
8. For failure (FSPOT = 20, 21, or 22), it could model glue connection. In this case, the force in secondary node will be scaled by reduced force coefficient ${f}_{N}$ ( ${f}_{T}$ ), which is computed as:(1)
$\begin{array}{l}{f}_{N}=\text{min}\left\{\sqrt{\frac{{\left({\sigma }_{N}^{\text{max}}\right)}^{2}}{\text{max}\left[{\left({\sigma }_{N}\left(t\right)\right)}^{2},{10}^{-20}\right]}},1\right\}\hfill \\ {f}_{T}=\text{min}\left\{\sqrt{\frac{{\left({\sigma }_{T}^{\text{max}}\right)}^{2}}{\text{max}\left[{\left({\sigma }_{T}\left(t\right)\right)}^{2},{10}^{-20}\right]},1}\right\}\hfill \end{array}$

The reduced force is compared to the maximum value:

If ${\sigma }_{N}<{\sigma }_{N}^{\text{max}}$ , then ${f}_{N}$ = 1, which means the force will not be reduced.

If ${\sigma }_{N}<{\sigma }_{N}^{\text{max}}$ , then ${f}_{N}=\sqrt{\frac{{\left({\sigma }_{N}^{\text{max}}\right)}^{2}}{\text{max}\left[{\left({\sigma }_{N}\left(t\right)\right)}^{2},{10}^{-20}\right]}}$ , which means the force will then be reduced.

Here the maximum value will be defined by you with:

$\begin{array}{l}{\sigma }_{N}^{\text{max}}=f\left(\stackrel{˙}{\sigma }\right)\cdot \text{SNTID}\left(\frac{\Delta {X}_{N}}{\text{FDIST}}\right)\hfill \\ {\sigma }_{T}^{\text{max}}=f\left(\stackrel{˙}{\sigma }\right)\cdot \text{STTID}\left(\frac{\Delta {X}_{N}}{\text{FDIST}}\right)\hfill \\ f\left(\stackrel{˙}{\sigma }\right)=\text{FSTR}\cdot \text{SRTID}\left(\frac{\stackrel{˙}{\sigma }}{\text{FSTRATE}}\right)\hfill \end{array}$

Where,
${\sigma }_{N}^{\text{max}}$
Maximum normal stress value defined by SNTID
${\sigma }_{N}\left(t\right)$
Normal stress
${\sigma }_{N}^{\text{max}}$
Maximum tangential stress value defined by STTID
${\sigma }_{T}\left(t\right)$
Tangential stress
FSTR
Input constant stress factor
SRTID
Input variable coefficient
SNTID and STTID
Input stress-displacement tables

Once the rupture criterion (defined by Rupt) is reached, the contact will be deleted.

9. If RUPT = 1, the failure criterion is:(2)
$\sqrt{{\left(\frac{\text{ND}}{\text{MAXND}}\right)}^{2}+{\left(\frac{\text{TD}}{\text{MAXTD}}\right)}^{2}}>1$
10. If FSPOT = 30, secondary mass/inertia/stiffness distribution to the main node is based on the Kirschoff model: bi-cubic form functions are used instead of linear (standard formulation). It allows a softer contact behavior since the element shape curvature is taken into account in the force/moment transmission.
11. If IDELG = 1, then when a 4-node shell, a 3-node shell or a solid element is deleted, it is also removed from the main side of the interface (kinematic condition is suppressed on relative slasecondaryve nodes).
12. If IFILT is set to 1, the normal and tangential stresses are filtered with an alpha filter, as: (3)
${\sigma }_{N}\left(t\right)=\text{ALPHA}×{\sigma }_{N}\left(t\right)+\left(1-\text{ALPHA}\right)×{\sigma }_{N}\left(t-1\right)$
(4)
${\sigma }_{T}\left(t\right)=\text{ALPHA}×{\sigma }_{T}\left(t\right)+\left(1-\text{ALPHA}\right)×{\sigma }_{T}\left(t-1\right)$
13. FSPOT = 25 (penalty formulation) will keep the penalty formulation during the whole run. The secondary node (of this contact) could also be the secondary node of another kinematic option, like rigid body. The penalty stiffness is constant, calculated as the mean nodal stiffness of main and secondary side. The stiffness factor, STFAC, may be used to modify it, if needed. The penalty stiffness will be multiplied by STFAC. A critical viscous damping coefficient (VISC) allows damping to be applied to the interface stiffness.


text:
\label{sup}\]. Therefore, we write down the force on $$q_2$$ from each and add them together as vectors. Thus, the entire mathematical analysis quickly becomes intractable. The net force would point $$58^o$$ below the −x-axis. \end{align*}\]. This calls for Coulomb’s law and superposition of forces. Join Yahoo Answers and get 100 points today. It has a very important physical meaning that we will discuss in a later chapter; for now, it is simply an empirical proportionality constant. ), The magnitude of the electric force (or Coulomb force) between two electrically charged particles is equal to, $\left|\mathbf{F}_{12}\right|=\frac{1}{4 \pi \varepsilon_{0}} \frac{\left|q_{1} q_{2}\right|}{r_{12}^{2}} \label{Coulomb}$. The direction of the force vector is along the imaginary line joining the two objects and is dictated by the signs of the charges involved. Missed the LibreFest? There are two forces: \begin{align*} \vec{F} &= \vec{F}_{21} + \vec{F}_{23} = \dfrac{1}{4\pi \epsilon_0}\left[\dfrac{q_2q_1}{r_{21}^2}\hat{j} + \left(-\dfrac{q_2q_3}{r_{23}^2}\hat{i}\right)\right]. Unlike the rubber rod of our macroscopic world, you cannot give charge to the neutron and you can neither add charge to, nor remove charge from, either the proton or the electron. Calculate the electric force on the electron due to the proton. If you also include negative signs from negative charges when you substitute numbers, you run the risk of mathematically reversing the direction of the force you are calculating. Unless otherwise noted, LibreTexts content is licensed by CC BY-NC-SA 3.0. This is a three-dimensional system, so the electron (and therefore the force on it) can be anywhere in an imaginary spherical shell around the proton. The proton has a charge of + e and the electron has − e. In the “ground state” of the atom, the electron orbits the proton at most probable distance of 5.29 × 10 − 11 m (Figure 5.4. That is the number of protons in the nucleus (as well as the number of electrons). What would be different in Example $$\PageIndex{2}$$ if $$q_1$$ were negative rather than positive? Just as the source charges each exert a force on the test charge, so too (by Newton’s third law) does the test charge exert an equal and opposite force on each of the source charges. In this expression, Q represents the charge of the particle that is experiencing the electric force $$\vec{F}$$, and is located at $$\vec{r}$$ from the origin; the $$q_i's$$ are the N source charges, and the vectors $$\vec{r}_i = r_i \hat{r}_i$$ are the displacements from the position of the ith charge to the position of $$Q$$. The discovery of the existence of the proton and its electrical charge occurred in related experiments conducted by British scientist Ernest Rutherford in 1917, first reported in 1919. With this restriction in place, the analysis of charges is known as electrostatics, where “statics” refers to the constant (that is, static) positions of the source charges and the force is referred to as an electrostatic force. charges one and two. F = 8.9875517873681764 * 10 9 * 1.602E-19 * … charge proton coulombs. Still have questions? These units are required to give the force in Coulomb’s law the correct units of newtons. Samuel J. Ling (Truman State University), Jeff Sanny (Loyola Marymount University), and Bill Moebs with many contributing authors. Calculate the electric force on the electron due to the proton. The amount of charge on both of the charged objects reflect the strength of the repulsive force. \nonumber. However, by Equation \ref{Coulomb}, the force on the test charge is a function of position; thus, as the positions of the source charges change, the net force on the test charge necessarily changes, which changes the force, which again changes the positions. All of this is depicted in Figure $$\PageIndex{2}$$. Calculate the electric force on the electron due to the proton. What would be different if the electron also had a positive charge? The electric force $$\vec{F}$$ on one of the charges is proportional to the magnitude of its own charge and the magnitude of the other charge, and is inversely proportional to the square of the distance between them: This proportionality becomes an equality with the introduction of a proportionality constant.

.

Uk Chocolate Market Statistics, Kathmandu Upatyaka Bikash Pradhikaran Syllabus, Cedar Lake, Manitoba, Warlord Titan Datasheet, Why Was The Sinking Of The Lusitania Important, Click And Grow Discount Code, Target Market For Chocolate Industry, This Old Routine First Aid Kit Lyrics, Collins Ks3 Science Book 3 Answers, Horus Heresy, The First Wall Pdf, Calories In Panera Strawberry Poppyseed Salad Without Dressing, Hotels In Rakiraki, Fiji, Bentley Vs Rolls-royce Price 2019,


text:
Search by Topic

Resources tagged with Visualising similar to Two's Company:

Filter by: Content type:
Stage:
Challenge level:

Square Coordinates

Stage: 3 Challenge Level:

A tilted square is a square with no horizontal sides. Can you devise a general instruction for the construction of a square when you are given just one of its sides?

Stage: 3 Challenge Level:

How many different symmetrical shapes can you make by shading triangles or squares?

On the Edge

Stage: 3 Challenge Level:

If you move the tiles around, can you make squares with different coloured edges?

Semi-regular Tessellations

Stage: 3 Challenge Level:

Semi-regular tessellations combine two or more different regular polygons to fill the plane. Can you find all the semi-regular tessellations?

Christmas Chocolates

Stage: 3 Challenge Level:

How could Penny, Tom and Matthew work out how many chocolates there are in different sized boxes?

Marbles in a Box

Stage: 3 Challenge Level:

How many winning lines can you make in a three-dimensional version of noughts and crosses?

Penta Colour

Stage: 4 Challenge Level:

In how many different ways can I colour the five edges of a pentagon red, blue and green so that no two adjacent edges are the same colour?

Isosceles Triangles

Stage: 3 Challenge Level:

Draw some isosceles triangles with an area of $9$cm$^2$ and a vertex at (20,20). If all the vertices must have whole number coordinates, how many is it possible to draw?

Picturing Square Numbers

Stage: 3 Challenge Level:

Square numbers can be represented as the sum of consecutive odd numbers. What is the sum of 1 + 3 + ..... + 149 + 151 + 153?

The Spider and the Fly

Stage: 4 Challenge Level:

A spider is sitting in the middle of one of the smallest walls in a room and a fly is resting beside the window. What is the shortest distance the spider would have to crawl to catch the fly?

Painted Cube

Stage: 3 Challenge Level:

Imagine a large cube made from small red cubes being dropped into a pot of yellow paint. How many of the small cubes will have yellow paint on their faces?

Picturing Triangle Numbers

Stage: 3 Challenge Level:

Triangle numbers can be represented by a triangular array of squares. What do you notice about the sum of identical triangle numbers?

An Unusual Shape

Stage: 3 Challenge Level:

Can you maximise the area available to a grazing goat?

Cuboid Challenge

Stage: 3 Challenge Level:

What size square corners should be cut from a square piece of paper to make a box with the largest possible volume?

Eight Hidden Squares

Stage: 2 and 3 Challenge Level:

On the graph there are 28 marked points. These points all mark the vertices (corners) of eight hidden squares. Can you find the eight hidden squares?

Square It

Stage: 3 and 4 Challenge Level:

Players take it in turns to choose a dot on the grid. The winner is the first to have four dots that can be joined to form a square.

Squares in Rectangles

Stage: 3 Challenge Level:

A 2 by 3 rectangle contains 8 squares and a 3 by 4 rectangle contains 20 squares. What size rectangle(s) contain(s) exactly 100 squares? Can you find them all?

Frogs

Stage: 3 Challenge Level:

How many moves does it take to swap over some red and blue frogs? Do you have a method?

Konigsberg Plus

Stage: 3 Challenge Level:

Euler discussed whether or not it was possible to stroll around Koenigsberg crossing each of its seven bridges exactly once. Experiment with different numbers of islands and bridges.

Route to Infinity

Stage: 3 Challenge Level:

Can you describe this route to infinity? Where will the arrows take you next?

Cubes Within Cubes Revisited

Stage: 3 Challenge Level:

Imagine starting with one yellow cube and covering it all over with a single layer of red cubes, and then covering that cube with a layer of blue cubes. How many red and blue cubes would you need?

Sea Defences

Stage: 2 and 3 Challenge Level:

These are pictures of the sea defences at New Brighton. Can you work out what a basic shape might be in both images of the sea wall and work out a way they might fit together?

Zooming in on the Squares

Stage: 2 and 3

Start with a large square, join the midpoints of its sides, you'll see four right angled triangles. Remove these triangles, a second square is left. Repeat the operation. What happens?

Instant Insanity

Stage: 3, 4 and 5 Challenge Level:

Given the nets of 4 cubes with the faces coloured in 4 colours, build a tower so that on each vertical wall no colour is repeated, that is all 4 colours appear.

The Old Goats

Stage: 3 Challenge Level:

A rectangular field has two posts with a ring on top of each post. There are two quarrelsome goats and plenty of ropes which you can tie to their collars. How can you secure them so they can't. . . .

Triangles Within Triangles

Stage: 4 Challenge Level:

Can you find a rule which connects consecutive triangular numbers?

All in the Mind

Stage: 3 Challenge Level:

Imagine you are suspending a cube from one vertex (corner) and allowing it to hang freely. Now imagine you are lowering it into water until it is exactly half submerged. What shape does the surface. . . .

A Tilted Square

Stage: 4 Challenge Level:

The opposite vertices of a square have coordinates (a,b) and (c,d). What are the coordinates of the other vertices?

Conway's Chequerboard Army

Stage: 3 Challenge Level:

Here is a solitaire type environment for you to experiment with. Which targets can you reach?

Triangles Within Pentagons

Stage: 4 Challenge Level:

Show that all pentagonal numbers are one third of a triangular number.

Fence It

Stage: 3 Challenge Level:

If you have only 40 metres of fencing available, what is the maximum area of land you can fence off?

Jam

Stage: 4 Challenge Level:

To avoid losing think of another very well known game where the patterns of play are similar.

Tetra Square

Stage: 3 Challenge Level:

ABCD is a regular tetrahedron and the points P, Q, R and S are the midpoints of the edges AB, BD, CD and CA. Prove that PQRS is a square.

Framed

Stage: 3 Challenge Level:

Seven small rectangular pictures have one inch wide frames. The frames are removed and the pictures are fitted together like a jigsaw to make a rectangle of length 12 inches. Find the dimensions of. . . .

Buses

Stage: 3 Challenge Level:

A bus route has a total duration of 40 minutes. Every 10 minutes, two buses set out, one from each end. How many buses will one bus meet on its way from one end to the other end?

Sliding Puzzle

Stage: 1, 2, 3 and 4 Challenge Level:

The aim of the game is to slide the green square from the top right hand corner to the bottom left hand corner in the least number of moves.

Threesomes

Stage: 3 Challenge Level:

Imagine an infinitely large sheet of square dotty paper on which you can draw triangles of any size you wish (providing each vertex is on a dot). What areas is it/is it not possible to draw?

Stage: 3 Challenge Level:

Choose a couple of the sequences. Try to picture how to make the next, and the next, and the next... Can you describe your reasoning?

Cubic Net

Stage: 4 and 5 Challenge Level:

This is an interactive net of a Rubik's cube. Twists of the 3D cube become mixes of the squares on the 2D net. Have a play and see how many scrambles you can undo!

Khun Phaen Escapes to Freedom

Stage: 3 Challenge Level:

Slide the pieces to move Khun Phaen past all the guards into the position on the right from which he can escape to freedom.

Changing Places

Stage: 4 Challenge Level:

Place a red counter in the top left corner of a 4x4 array, which is covered by 14 other smaller counters, leaving a gap in the bottom right hand corner (HOME). What is the smallest number of moves. . . .

Dice, Routes and Pathways

Stage: 1, 2 and 3

This article for teachers discusses examples of problems in which there is no obvious method but in which children can be encouraged to think deeply about the context and extend their ability to. . . .

Inside Out

Stage: 4 Challenge Level:

There are 27 small cubes in a 3 x 3 x 3 cube, 54 faces being visible at any one time. Is it possible to reorganise these cubes so that by dipping the large cube into a pot of paint three times you. . . .

Muggles Magic

Stage: 3 Challenge Level:

You can move the 4 pieces of the jigsaw and fit them into both outlines. Explain what has happened to the missing one unit of area.

Squares, Squares and More Squares

Stage: 3 Challenge Level:

Can you dissect a square into: 4, 7, 10, 13... other squares? 6, 9, 12, 15... other squares? 8, 11, 14... other squares?

Coordinate Patterns

Stage: 3 Challenge Level:

Charlie and Alison have been drawing patterns on coordinate grids. Can you picture where the patterns lead?

Pattern Power

Stage: 1, 2 and 3

Mathematics is the study of patterns. Studying pattern is an opportunity to observe, hypothesise, experiment, discover and create.

Convex Polygons

Stage: 3 Challenge Level:

Show that among the interior angles of a convex polygon there cannot be more than three acute angles.

Cubes Within Cubes

Stage: 2 and 3 Challenge Level:

We start with one yellow cube and build around it to make a 3x3x3 cube with red cubes. Then we build around that red cube with blue cubes and so on. How many cubes of each colour have we used?

Coloured Edges

Stage: 3 Challenge Level:

The whole set of tiles is used to make a square. This has a green and blue border. There are no green or blue tiles anywhere in the square except on this border. How many tiles are there in the set?


text:
## Section0.6Programming Languages

Most computer programs today are written in a high-level language , such as Java, Python, C, C++, or FORTRAN.

A programming language is considered high level if its statements resemble English-language statements. For example, all of the languages just mentioned have some form of an “if” statement, which says, “if some condition holds, then take some action.”

Computer scientists have invented hundreds of high-level programming languages, although relatively few of these have been put to practical use.

Some of the widely used languages have special features that make them suitable for one type of programming application or another. COBOL (COmmon Business-Oriented Language), for example, is still used in commercial applications. FORTRAN (FORmula TRANslator) is still preferred by some engineers and scientists. C and C++ are still the primary languages used by operating system programmers.

In addition to having features that make them suitable for certain types of applications, high-level languages use symbols and notation that make them easily readable by humans. For example, arithmetic operations in Java make use of familiar operators such as “$$+$$” and “$$-$$” and “/”, so that arithmetic expressions look more or less the way they do in algebra. So, to take the average of two numbers, you might use the expression

 (a + b) / 2

### Subsection0.6.1Machine Languages

The problem is that computers cannot directly understand high-level languages.. In order for a computer to run a program, it must first be translated into the computer's machine language , which is the language understood by its CPU or microprocessor.

Each type of microprocessor has its own particular machine language. That's why when you buy software it typically runs on either a Macintosh or on a Windows machine, but not on both. If a program can run on just one type of chip, it is known as platform dependent .

In general, machine languages are based on the binary code, a two-valued system that is well suited for electronic devices. In a binary representation scheme, everything is represented as a sequence of 1's and 0's, which corresponds closely to the computer's electronic “on” and “off” states.

For example, in binary code, the number 13 would be represented as 1101. Similarly, a particular address in the computer's memory might be represented as 01100011, and an instruction in the computer's instruction set might be represented as 001100.

The instructions that make up a computer's machine language are very simple and basic. For example, a typical machine language might include instructions for ADD, SUBTRACT, DIVIDE, and MULTIPLY, but it wouldn't contain an instruction for AVERAGE.

In most cases, a single instruction, called an opcode, carries out a single machine operation on one or more pieces of data, called its operands. Therefore, the process of averaging two numbers would have to be broken down into two or more steps.

A machine language instruction itself might have something similar to the following format, in which an opcode is followed by several operands, which refer to the locations in the computer's primary memory where the data are stored. The following instruction says ADD the number in LOCATION1 to the number in LOCATION2 and store the result in LOCATION3:

 Opcode Operand 1 Operand 2 Operand 3 011110 110110 111100 111101 (ADD) (LOCATION 1) (LOCATION 2) (LOCATION 3)

Given the primitive nature of machine language, an expression like $$(a + b)/2$$ would have to be translated into a sequence of several machine language instructions that, in binary code, might look as follows:

 011110110110111100111101 000101000100010001001101 001000010001010101111011

In the early days of computing, before high-level languages were developed, computers had to be programmed directly in their machine languages, an extremely tedious and error-prone process. Imagine how difficult it would be to detect an error that consisted of putting a 0 in the preceding program where a 1 should occur!

### Subsection0.6.2Translating High-level Programs

Fortunately, we no longer have to worry about machine languages, because special system software can be used to translate a high-level or source code program into machine language code or object code , which is the only code that can be executed or run by the computer.

In general, a program that translates source code to object code is known as a translator (Figure 0.6.1). Thus, with suitable translation software for Java or C++ we can write programs as if the computer could understand Java or C++ directly.

Source code translators come in two varieties. An interpreter translates a single line of source code directly into machine language and executes the code before going on to the next line of source code. A compiler translates the entire source code program into executable object code, which means that the object code can then be run directly without further translation.

There are advantages and disadvantages to both approaches. Interpreted programs generally run less efficiently than compiled programs, because they must translate and execute each line of the program before proceeding to the next line. If a line of code is repeated, an interpreter would have to translate the line each time it is encountered. By contrast, once compiled, an object program is just executed without any need for further translation.

It is also much easier to refine compiled code to make it run more efficiently. But interpreters are generally quicker and easier to develop and provide somewhat better error messages when things go wrong.

Some languages that you may have heard of, such as BASIC, LISP, Python, and Perl, are mostly used in interpreted form, although compilers are also available for these languages. Programs written in COBOL, FORTRAN, C, C++, and Pascal are compiled.

As we will see in the next section, Java programs use both compilation and interpretation in their translation process.


text:
Some terminology

Having set the mood with our last post, we now return to “The Book” and examine “covering all small products”. I want to use this post to try out some terminology to see if it’s possible to make the material a little more palatable.

Definition 1 Let ${\mathfrak{a}}$ be a set of regular cardinals, let ${\sigma}$ be a regular cardinal, and let ${F\subseteq\prod\mathfrak{a}}$. Given a set ${\mathfrak{b}\subseteq\mathfrak{a}}$, we say that ${F}$ is ${<\sigma}$-cofinal in ${\prod\mathfrak{b}}$ if for any function ${f\in\prod\mathfrak{a}}$, there is a family ${F_0}$ of fewer than ${\sigma}$ elements of ${F}$ such that

$\displaystyle f(\eta)<\sup\{g(\eta):g\in F_0\}\text{ for all }\eta\in \mathfrak{b}. \ \ \ \ \ (1)$

In the last post, we characterized the minimum cardinality of a ${<\sigma}$-cofinal subset of ${\prod\mathfrak{a}}$ in the case where ${\mathfrak{a}}$ is progressive and ${\sigma<|\mathfrak{a}|}$. Today, I want to consider a related question:

What is the minimum cardinality of a family ${F\subseteq\prod\mathfrak{a}}$ such that ${F}$ is ${<\sigma}$-cofinal in ${\mathfrak{b}}$ for every ${\mathfrak{b}\subseteq\mathfrak{a}}$ of cardinality ${<\theta}$?

Let us agree to denote the above cardinal by ${{\rm cf}^{\sigma}_{<\theta}(\prod\mathfrak{a})}$ (again, don’t blame me for the notation!).

Ok, so why on earth would I want to consider such a cardinal? Well, we’re going to see that this is actually quite relevant for cardinal arithmetic — we will show that such cardinals are intimately tied up with Shelah’s covering numbers. Our first task, though, will be to characterize such cardinals in terms of pcf theory. The characterization will require a little terminology.

Definition 2 Suppose ${\mathfrak{a}}$ is a progressive set of regular cardinals, and let ${\sigma}$ and ${\theta}$ be cardinals such that

$\displaystyle \aleph_0\leq{\rm cf}(\sigma)=\sigma<\theta\leq|\mathfrak{a}|. \ \ \ \ \ (2)$

We define the set ${{\rm pcf}_{\Gamma(\theta,\sigma)}(\mathfrak{a})}$ to consist of all (regular) cardinals ${\kappa}$ for which there is an ideal ${J}$ on ${\mathfrak{a}}$ such that

• ${J}$ is ${\sigma}$-complete,
• ${(\prod\mathfrak{a}, <_J)}$ has true cofinality ${\kappa}$, and
• there is a ${\mathfrak{b}\subseteq\mathfrak{a}}$ such that ${|\mathfrak{b}|<\theta}$ and ${\mathfrak{a}\setminus\mathfrak{b}\in J}$.

Notice that the above is very close to the definition of ${{\rm pcf}_{\sigma{\rm-complete}}(\mathfrak{a})}$; the difference is that the last clause further restricts the acceptable ideals to those which also “reduce” ${\prod\mathfrak{a}}$ to something of the form ${\prod\mathfrak{b}}$ where ${|\mathfrak{b}|<\theta}$.

We’ll end this post with the statement of a theorem; we’ll prove the theorem in the next post.

Theorem 3 Suppose ${\mathfrak{a}}$ is a progressive set of regular cardinals, and

$\displaystyle \aleph_0\leq{\rm cf}(\sigma)=\sigma<\theta\leq|\mathfrak{a}|. \ \ \ \ \ (3)$

Then

$\displaystyle {\rm cf}^\sigma_{<\theta}(\prod\mathfrak{a})=\sup{\rm pcf}_{\Gamma(\theta,\sigma)}(\mathfrak{a}). \ \ \ \ \ (4)$


text:
Various Patterns of Iteratee
Created at 2016-05-03T21:09:11.000Z

On the way of creating my first Haskell web app with snap, I came across with Iteratee. Since I have a background of studying Category Theory (especially Coalgebra Theory), it was easy to understand the definition of Iteratee in its simplest form explained in Haskell Wiki. But, at certain point, the real/practical definition of Iteratee overwhelmed me.

So, this post (and my implementations IterateeNonWaitable, IterateeWaitable) is:

• to fill the gap between the simplest form and practical form, and,
• to re-explain some notions of Iteratee with Category Theory.

Simplest Definition

Starting from the definition of "Simplest" Iteratee I've used in IterateeNonWaitable:

data Iteratee s a
= Continue (s -> Iteratee s a)
| Yield a

This algebraic data type satisfies the equation below (here Iteratee s = $T_{s}$):

$$T_{S}(A) = T_{S}(A)^S + A.$$

So, this Monad can be written with $\mu$ notation:

$$T_{S}(A) = \mu X. (X^S + A)$$

If you look at the page 3 in the paper Notions of computation and monads, Eugenio Moggi, you'll see this definition is exactly same to what's introduced as "interactive input monad", $T(A) = (\mu\gamma.A + \gamma^U)$.

Considering $X^S = \prod_{s \in S}X$, each element can be considered to be some kind of tree as below:

"Waitable" Definition

I found the previous definition is too weak to accommodate "waiting-for-coming-input" state. So, I changed a definition from IterateeNonWaitable to IterateeWaitable

data Iteratee s a
= Continue (Maybe s -> Iteratee s a)
| Yield s

This Iteratee explicitly assumes input set includes "waiting instruction" which I represent by Nothing. (In the real defintion, empty chunk is used for the same purpose.)

Here is a tree representation for this pattern of definition:

Summery

• no monad transformation (so it cannot accommodate IO processing)
• no Exception constructor
• no Chunk or EOF
• not leave stream (Yield only leaves result a)
• "Waitable" has Nothing as waiting state
• enumerator composition doesn't work for "NonWaitable" iteratee defintion
• it's impossible to implement listFunction2Iteratee for "NonWaitable" since Nothing input did good ad-hocly

Original implementation

• practical implementation of "interatcive input output monad"
• Chunk-ed input
• explicit EOF as input
• explicit Exception state

• Enumerator is not a theoretically solid notion as Iteratee. This is only for ad-hoc programatic notion.

Future Work

• Define Iteratee via free monad:

• Derive Monad definition via GHC "deriving" mechanism

• Theoretical foudnation for Enumeratee:

• it might be a practical ad-hoc notion similer to Enumerator, but it might be theoretically interesting.
• Give deeper explanation using _Final Coalgebra_
• I've ignored the fact that Haskell's algebraic data type accommodates infinite structure. So, technically/theoretically, the definition of Iteratee should be considered as Final Coalgebra:


text:
# 16.16: Countercurrent Separations

In 1949, Lyman Craig introduced an improved method for separating analytes with similar distribution ratios [Craig, L. C. J. Biol. Chem. 1944, 155, 519–534]. The technique, which is known as a countercurrent liquid–liquid extraction, is outlined in Figure $$\PageIndex{1}$$ and discussed in detail below. In contrast to a sequential liquid–liquid extraction, in which we repeatedly extract the sample containing the analyte, a countercurrent extraction uses a serial extraction of both the sample and the extracting phases. Although countercurrent separations are no longer common—chromatographic separations are far more efficient in terms of resolution, time, and ease of use—the theory behind a countercurrent extraction remains useful as an introduction to the theory of chromatographic separations.

To track the progress of a countercurrent liquid-liquid extraction we need to adopt a labeling convention. As shown in Figure $$\PageIndex{1}$$, in each step of a countercurrent extraction we first complete the extraction and then transfer the upper phase to a new tube that contains a portion of the fresh lower phase. Steps are labeled sequentially beginning with zero. Extractions take place in a series of tubes that also are labeled sequentially, starting with zero. The upper and lower phases in each tube are identified by a letter and number, with the letters U and L representing, respectively, the upper phase and the lower phase, and the number indicating the step in the countercurrent extraction in which the phase was first introduced. For example, U0 is the upper phase introduced at step 0 (during the first extraction), and L2 is the lower phase introduced at step 2 (during the third extraction). Finally, the partitioning of analyte in any extraction tube results in a fraction p remaining in the upper phase, and a fraction q remaining in the lower phase. Values of q are calculated using Equation \ref{16.1}, which is identical to Equation 7.7.6 in Chapter 7.

$(q_\text{aq})_1 = \frac {(\text{mol aq})_1} {(\text{mol aq})_0} = \frac {V_\text{aq}} {D V_\text{org} + V_\text{aq}} \label{16.1}$

The fraction p, of course is equal to 1 – q. Typically Vaq and Vorg are equal in a countercurrent extraction, although this is not a requirement.

Let’s assume that the analyte we wish to isolate is present in an aqueous phase of 1 M HCl, and that the organic phase is benzene. Because benzene has the smaller density, it is the upper phase, and 1 M HCl is the lower phase. To begin the countercurrent extraction we place the aqueous sample that contains the analyte in tube 0 along with an equal volume of benzene. As shown in Figure $$\PageIndex{1}\text{a}$$, before the extraction all the analyte is present in phase L0. When the extraction is complete, as shown in Figure $$\PageIndex{1}\text{b}$$, a fraction p of the analyte is present in phase U0, and a fraction q is in phase L0. This completes step 0 of the countercurrent extraction. If we stop here, there is no difference between a simple liquid–liquid extraction and a countercurrent extraction.

After completing step 0, we remove phase U0 and add a fresh portion of benzene, U1, to tube 0 (see Figure $$\PageIndex{1}\text{c}$$). This, too, is identical to a simple liquid-liquid extraction. Here is where the power of the countercurrent extraction begins—instead of setting aside the phase U0, we place it in tube 1 along with a portion of analyte-free aqueous 1 M HCl as phase L1 (see Figure $$\PageIndex{1}\text{c}$$). Tube 0 now contains a fraction q of the analyte, and tube 1 contains a fraction p of the analyte. Completing the extraction in tube 0 results in a fraction p of its contents remaining in the upper phase, and a fraction q remaining in the lower phase. Thus, phases U1 and L0 now contain, respectively, fractions pq and q2 of the original amount of analyte. Following the same logic, it is easy to show that the phases U0 and L1 in tube 1 contain, respectively, fractions p2 and pq of analyte. This completes step 1 of the extraction (see Figure $$\PageIndex{1}\text{d}$$). As shown in the remainder of Figure $$\PageIndex{1}$$, the countercurrent extraction continues with this cycle of phase transfers and extractions.

In a countercurrent liquid–liquid extraction, the lower phase in each tube remains in place, and the upper phase moves from tube 0 to successively higher numbered tubes. We recognize this difference in the movement of the two phases by referring to the lower phase as a stationary phase and the upper phase as a mobile phase. With each transfer some of the analyte in tube r moves to tube $$r + 1$$, while a portion of the analyte in tube $$r - 1$$ moves to tube r. Analyte introduced at tube 0 moves with the mobile phase, but at a rate that is slower than the mobile phase because, at each step, a portion of the analyte transfers into the stationary phase. An analyte that preferentially extracts into the stationary phase spends proportionally less time in the mobile phase and moves at a slower rate. As the number of steps increases, analytes with different values of q eventually separate into completely different sets of extraction tubes.

We can judge the effectiveness of a countercurrent extraction using a histogram that shows the fraction of analyte present in each tube. To determine the total amount of analyte in an extraction tube we add together the fraction of analyte present in the tube’s upper and lower phases following each transfer. For example, at the beginning of step 3 (see Figure $$\PageIndex{1}\text{g}$$) the upper and lower phases of tube 1 contain fractions pq2 and 2pq2 of the analyte, respectively; thus, the total fraction of analyte in the tube is 3pq2. Table $$\PageIndex{1}$$ summarizes this for the steps outlined in Figure $$\PageIndex{1}$$. A typical histogram, calculated assuming distribution ratios of 5.0 for analyte A and 0.5 for analyte B, is shown in Figure $$\PageIndex{2}$$. Although four steps is not enough to separate the analytes in this instance, it is clear that if we extend the countercurrent extraction to additional tubes, we will eventually separate the analytes.

Table $$\PageIndex{1}$$. Fraction of Analyte Remaining in Tube r After Extraction Step n for a Countercurrent Extraction
$$\ce{n} \ce{v} \ce{r} \ce{->}$$ 0 1 2 3
0 1
1 q p
2 q2 2pq p2
3 q3 3pq 3p2q p3

Figure $$\PageIndex{1}$$ and Table $$\PageIndex{1}$$ show how an analyte’s distribution changes during the first four steps of a countercurrent extraction. Now we consider how we can generalize these results to calculate the amount of analyte in any tube, at any step during the extraction. You may recognize the pattern of entries in Table $$\PageIndex{1}$$ as following the binomial distribution

$f(r, n) = \frac {n!} {(n - r)! r!} p^{r} q^{n - r} \label{16.2}$

where f(r, n) is the fraction of analyte present in tube r at step n of the countercurrent extraction, with the upper phase containing a fraction $$p \times f(r, n)$$ of analyte and the lower phase containing a fraction $$q \times f(r, n)$$ of the analyte.

Example $$\PageIndex{1}$$

The countercurrent extraction shown in Figure $$\PageIndex{2}$$ is carried out through step 30. Calculate the fraction of analytes A and B in tubes 5, 10, 15, 20, 25, and 30.

Solution

To calculate the fraction, q, for each analyte in the lower phase we use Equation \ref{16.1}. Because the volumes of the lower and upper phases are equal, we get

$q_\text{A} = \frac {1} {D_\text{A} + 1} = \frac {1} {5 + 1} = 0.167 \quad \quad q_\text{B} = \frac {1} {D_\text{B} + 1} = \frac {1} {0.5 + 1} = 0.667 \nonumber$

Because we know that $$p + q = 1$$, we also know that pA is 0.833 and that pB is 0.333. For analyte A, the fraction in tubes 5, 10, 15, 20, 25, and 30 after the 30th step are

$f(5,30) = \frac {30!} {(30 - 5)! 5!} (0.833)^{5} (0.167)^{30 - 5} = 2.1 \times 10^{-15} \approx 0 \nonumber$

$f(10,30) = \frac {30!} {(30 - 10)! 10!} (0.833)^{10} (0.167)^{30 - 10} = 1.4 \times 10^{-9} \approx 0 \nonumber$

$f(15,30) = \frac {30!} {(30 - 15)! 5!} (0.833)^{15} (0.167)^{30 - 15} = 2.2 \times 10^{-5} \approx 0 \nonumber$

$f(20,30) = \frac {30!} {(30 - 20)! 20!} (0.833)^{20} (0.167)^{30 - 20} = 0.013 \nonumber$

$f(25,30) = \frac {30!} {(30 - 25)! 25!} (0.833)^{25} (0.167)^{30 - 25} = 0.192 \nonumber$

$f(30,30) = \frac {30!} {(30 - 30)! 30!} (0.833)^{30} (0.167)^{30 - 30} = 0.004 \nonumber$

The fraction of analyte B in tubes 5, 10, 15, 20, 25, and 30 is calculated in the same way, yielding respective values of 0.023, 0.153, 0.025, 0, 0, and 0. Figure $$\PageIndex{3}$$, which provides the complete histogram for the distribution of analytes A and B, shows that 30 steps is sufficient to separate the two analytes.

Constructing a histogram using Equation \ref{16.2} is tedious, particularly when the number of steps is large. Because the fraction of analyte in most tubes is approximately zero, we can simplify the histogram’s construction by solving Equation \ref{16.2} only for those tubes containing an amount of analyte that exceeds a threshold value. For a binomial distribution, we can use the mean and standard deviation to determine which tubes contain a significant fraction of analyte. The properties of a binomial distribution were covered in Chapter 4, with the mean, $$\mu$$, and the standard deviation, $$\sigma$$, given as

$\mu = np \nonumber$

$\sigma = \sqrt{np(1 - p)} = \sqrt{npq} \nonumber$

Furthermore, if both np and nq are greater than 5, then a binomial distribution closely approximates a normal distribution and we can use the properties of a normal distribution to determine the location of the analyte and its recovery [see Mark, H.; Workman, J. Spectroscopy 1990, 5(3), 55–56].

Example $$\PageIndex{2}$$

Two analytes, A and B, with distribution ratios of 9 and 4, respectively, are separated using a countercurrent extraction in which the volumes of the upper and lower phases are equal. After 100 steps determine the 99% confidence interval for the location of each analyte.

Solution

The fraction, q, of each analyte that remains in the lower phase is calculated using Equation \ref{16.1}. Because the volumes of the lower and upper phases are equal, we find that

$q_\text{A} = \frac {1} {D_\text{A} + 1} = \frac {1} {9 + 1} = 0.10 \quad \quad q_\text{B} = \frac {1} {D_\text{B} + 1} = \frac {1} {4 + 1} = 0.20 \nonumber$

Because we know that $$p + q = 1$$, we also know that pA is 0.90 and pB is 0.80. After 100 steps, the mean and the standard deviation for the distribution of analytes A and B are

$\mu_\text{A} = np_\text{A} = (100)(0.90) = 90 \text{ and } \sigma_\text{A} = \sqrt{np_\text{A}q_\text{A}} = \sqrt{(100)(0.90)(0.10)} = 3 \nonumber$

$\mu_\text{B} = np_\text{B} = (100)(0.80) = 80 \text{ and } \sigma_\text{A} = \sqrt{np_\text{A}q_\text{A}} = \sqrt{(100)(0.80)(0.20)} = 4 \nonumber$

Given that npA, npB, nqA, and nqB are all greater than 5, we can assume that the distribution of analytes follows a normal distribution and that the confidence interval for the tubes containing each analyte is

$r = \mu \pm z \sigma \nonumber$

where r is the tube’s number and the value of z is determined by the desired significance level. For a 99% confidence interval the value of z is 2.58 (see Appendix 4); thus,

$r_\text{A} = 90 \pm (2.58)(3) = 90 \pm 8 \nonumber$

$r_\text{B} = 80 \pm (2.58)(4) = 80 \pm 10 \nonumber$

Because the two confidence intervals overlap, a complete separation of the two analytes is not possible using a 100 step countercurrent extraction. The complete distribution of the analytes is shown in Figure $$\PageIndex{4}$$.

Example $$\PageIndex{3}$$

For the countercurrent extraction in Example $$\PageIndex{2}$$, calculate the recovery and the separation factor for analyte A if the contents of tubes 85–99 are pooled together.

Solution

From Example $$\PageIndex{2}$$ we know that after 100 steps of the countercurrent extraction, analyte A is normally distributed about tube 90 with a standard deviation of 3. To determine the fraction of analyte A in tubes 85–99, we use the single-sided normal distribution in Appendix 3 to determine the fraction of analyte in tubes 0–84, and in tube 100. The fraction of analyte A in tube 100 is determined by calculating the deviation z

$z = \frac {r - \mu} {\sigma} = \frac {99 - 90} {3} = 3 \nonumber$

and using the table in Appendix 3 to determine the corresponding fraction. For z = 3 this corresponds to 0.135% of analyte A. To determine the fraction of analyte A in tubes 0–84 we again calculate the deviation

$z = \frac {r - \mu} {\sigma} = \frac {84 - 90} {3} = -1.67 \nonumber$

From Appendix 3 we find that 4.75% of analyte A is present in tubes 0–84. Analyte A’s recovery, therefore, is

$100\% - 4.75\% - 0.135\% \approx 95\% \nonumber$

To calculate the separation factor we determine the recovery of analyte B in tubes 85–99 using the same general approach as for analyte A, finding that approximately 89.4% of analyte B remains in tubes 0–84 and that essentially no analyte B is in tube 100. The recovery for B, therefore, is

$100\% - 89.4\% - 0\% \approx 10.6\% \nonumber$

and the separation factor is

$S_\text{B/A} = \frac {R_\text{A}} {R_\text{B}} = \frac {10.6} {95} = 0.112 \nonumber$

16.16: Countercurrent Separations is shared under a CC BY-NC-SA license and was authored, remixed, and/or curated by David Harvey.


text:
# staircase.Stairs.sample¶

Stairs.sample(x, how='right', aggfunc=None, window=(0, 0), lower_how='right', upper_how='left')

Evaluates the value of the step function at one, or more, points.

This method can be used to directly sample values of the corresponding step function at the points provided, or alternatively calculate aggregations over some window around each point. The first of these is performed when aggfunc is None.

If aggfunc is None then the results of this function should be considered as $$\lim_{x \to z^{-}} f(x)$$ or $$\lim_{x \to z^{+}} f(x)$$, when how = ‘left’ or how = ‘right’ respectively. See A note on interval endpoints for an explanation.

If aggfunc is not None then a window, around each point x (referred to as the focal point), over which to aggregate is required. The window is defined by two values paired into an array-like parameter called window. These two scalars are the distance from the focal point to the left boundary of the window, and the right boundary of the window respectively.

The function can be called using parentheses. See example below.

Parameters: x (int, float or vector data) – Values at which to evaluate the function how ({'left', 'right'}, default 'right') – Only relevant if aggfunc is None. If points where step changes occur do not coincide with x then this parameter has no effect. Where a step changes occurs at a point given by x, this parameter determines if the step function is evaluated at the interval to the left, or the right. aggfunc ({'mean', 'median', 'mode', 'max', 'min', 'std', None}. Default None.) – A string corresponding to the aggregating function window (array-like of int, float or pandas.Timedelta, optional) – Only relevant if aggfunc is not None. Should be length of 2. Defines distances from focal point to window boundaries. lower_how ({'left', 'right'}, default 'right') – Only relevant if aggfunc is not None. Determines how the left window boundary should be evaluated. If ‘left’ then $$\lim_{x \to lower_how^{-}} f(x)$$ is included in the window. upper_how ({'left', 'right'}, default 'left') – Only relevant if aggfunc is not None. Determines how the right window boundary should be evaluated. If ‘right’ then $$\lim_{x \to upper_how^{+}} f(x)$$ is included in the window. float, or list of floats

Examples

>>> s1.plot()
>>> s1(3.5)
1
>>> s1([1, 2, 4.5, 6])
[1, 0, -1, 0]
>>> s1([1, 2, 4.5, 6], how="left")
[0, 1, -1, 0]
>>> s1([1, 2, 4.5], aggfunc="mean", window=(-0.5, 0.5))
[0.5, 0.5, -1.0]
>>> s1([1, 2, 4.5], aggfunc="max", window=(-0.5, 0.5))
[1, 1, -1]
>>> s1([1, 2, 4.5], aggfunc="max", window=(-0.5, 0.5), lower_how="left")
[1, 1, 1]
>>> s1([1, 2, 4.5], aggfunc="max", window=(-0.5, 0.5), upper_how="right")
[1, 1, 0]


text:
# SF1 Loudspeaker Base Pair

by Dynaudio
\$109.00

The ideal solution for the installation of compact speakers and center speakers on sideboards, low-boards and shelves.

The SF1 optimizes loudspeaker performance with minimum effort or space: The SF1 places the speaker with a slight upward tilt, thus minimizing the impact of surface reflections on the sound quality which would otherwise occur from the underlying foundation.

It is ideal for use with the Dynaudio LYD 5, LYD 7, Emit M10 and M20, DM 2/6 and 2.7, Excite X14 and X14A, Xeo 3 or Xeo 4, as well, of course, with myriad other compact loudspeakers.