text:
Random Maps 3 – Leaves and Geodesics in BCRT

Recall in the previous two posts, we’ve introduced some of the background to maps on various surfaces. In particular, we’ve introduced the remarkable Cori-Vauquelin-Schaeffer bijection which maps between plane trees labelled with uniform increments and quadrangulations of the sphere, up to some careful fiddling around with rooting and pointing an edge.

We are interested in the case where we choose uniformly a large element from these classes. We want to derive a scaling limit for the uniform planar quadrangulation, and we hope that we will be able to carry some properties of the scaling limit of the labelled trees, which may well be simpler, across the CVS bijection. It is convenient that the vertices of the plane tree become the vertices of the quadrangulation. We are looking to find some sort of metric limit, in the Gromov-Hausdorff sense, and so it will remain to deduce exactly how to use the labelling obtained from the tree to gain information about distances in the (limiting) quadrangulation.

Of course, all of this relies on the fact that there is a nice limit for the ordered plane trees in the first place. Unsurprisingly, it turns out that this is Aldous’s Brownian continuum random tree. The easiest way to see this is to consider the contour process of the ordered plane tree. This is chosen uniformly at random from the set of paths from (0,0) to (2n,0) with increments of size {-1,1} and which stay non-negative. It is thus precisely a simple random walk started at (0,0) conditioned to hit (2n,0) and to be non-negative. Since SRW suitably rescaled converges to Brownian motion, it is unsurprising (but not totally trivial) that this conditioned object converges to a Brownian excursion.

The Brownian excursion can be viewed as a continuous analogue of the contour process for the BCRT, but it is more natural to consider this convergence in the Gromov-Hausdorff topology. In this setting, we say that for a large value of n, the tree is ‘roughly isometric’ to the BCRT in distribution. Here, roughly isometric means the two metric spaces can be embedded isometrically into a common metric space such that they are close together, now in the sense of Hausdorff distance.

At this point, it is worth thinking about this interpretation of the BCRT. We have previously considered this as the scaling limit of a uniformly chosen Cayley tree, that is any unrooted tree on n labelled vertices. Essentially, we are now specifying that the BCRT can carry extra information, namely a root, and geometric information about the order of branches. The root is uncontroversial. Canonically, the root of the BCRT will be at the point associated with time 0 in the driving Brownian excursion. However, we can easily check that the distribution of a uniform rooted plane tree is invariant under re-rooting, and so any argument we have for convergence of the rooted trees to the BCRT will work with the root in a different place. Applying something like a tower law, we conclude that the convergence works when the root is chosen uniformly in the limit.

One potential problem to be discussed is what it means to choose a point uniformly in the limit. We have two possible approaches. One is to consider Lebesgue measure on any path in the BCRT, and glue these together. However, we have a uniform stick-breaking construction of the BCRT, and one consequence of the construction is that the total length of sticks required is infinite, so this won’t work.

The other option is to project Lebesgue measure on [0,1] via the same map that sends points on the Brownian excursion to points in the tree. Note that the so-called real tree is constructed from the excursion by identifying points s and t where f(s)=f(t), and f(x)>f(s) for x in (s,t). But then we might wonder whether this can really be said to be ‘uniform’, since different points in the BCRT will have a different number of pre-images in [0,1]. In fact though, it turns out that in this sense, projected-Leb[0,1]-almost all the points in the BCRT are leaves.

To prove this, naturally we first need to define a leaf, in the setting of these continuum trees. The degree of a vertex is an idea we might keep in mind, but we can’t use this, as we don’t have vertices any more. However, we have a continuous analogue of degree, given by counting the number of connected components remaining after removing a vertex. In particular, we can define the set of leaves as

$\mathcal{L}(\mathcal{T}):=\{x\in\mathcal{T}:\mathcal{T}\backslash \{x\}\text{ is connected}\}.$

We will give a sketch proof of this result about leaves shortly. First, we clarify some notation, and consider properties of geodesics (shortest-length paths) in the tree.

Define $\check{f}(u,v):=\min_{x\in[u\wedge v,u\vee v]} f(x)$ to be the minimum value attained by f between u and v. Consider the value x at which this minimum is attained. Then, projecting onto the tree, p(x) is the ‘most recent common ancestor’ of points u and v. We can make this a bit more precise by considering geodesics in the tree starting at the root. Analogous to the unique path property in a discrete tree, in this continuous setting there is a unique path from the root to any given point, along which the height is strictly increasing. This is not surprising. It follows from one of the definitions of a real tree that the length of the path from p(0) to p(s) should be f(s), and so there is a unique isometric embedding of [0,f(s)] into $\mathcal{T}_f$ which starts at 0 and ends at p(s). Anyway, under this $p(\check{f}(s,t))$ gives the point at which the geodesics from p(s) to p(0) and from p(t) to p(0) meet.

Furthermore, we can now describe the distance in the tree between p(s) and p(t). This is given by

$d_f(s,t):= f(s)+f(t)-2\check{f}(s,t),$

and with the geodesic picture, it is easy to see why. Consider the point x at which $\check{f}(s,t)$ achieves the minimum. As we have said, this lies on the geodesics from p(s) to 0 and p(t) to 0, and paths between points are unique, so removing point x disconnects p(s) and p(t) in the tree. So we need to concatenate the geodesic from p(s) to p(x) and from p(x) to p(t). But these are subsets of the two geodesics discussed, and their respective lengths are $f(s)-\check{f}(s,t)$ and $f(t)-\check{f}(s,t)$.

We can now give a sketch proof the result that almost all the support of $\lambda_f$, the projection on Lebesgue measure from [0,1] onto $\mathcal{T}_{f}$ is on $\mathcal{T}(\mathcal{T}_f)$.

Given $s,t\in[0,1]$, suppose we are removing p(s), and this separates p(t) from the root, which is canonically p(0). Without loss of generality, take t>s. Now suppose that $\check{f}(s,t), and that, as before, this infimum is attained at $x\in[s,t]$. Then the geodesic from p(0) to p(t) will pass through p(x), but not through p(s), so in particular, removing p(s) cannot disconnect p(t) from the root.

Thus, p(s) is not a leaf if and only if there exists some small window [s,t] such that $f(s)\le f(x),\;\forall x\in[s,t]$. By Blumenthal’s 0-1 law, for fixed x, this happens with probability 0 if f is Brownian motion. Here, f is not Brownian motion, but a Brownian excursion with length 1. However, Blumenthal’s 0-1 law depends on the instantaneous behaviour after time s, ie the sigma field $\mathcal{F}_s^+$. So, for $s\in(0,1)$, the value of a Brownian at time 1 is independent of this sigma field, so if we imagine Brownian excursion as a ‘conditioned’ Brownian motion, this conditioning should have no effect on the conclusion of this corollary to Blumenthal’s 0-1 law.

This is not a formal argument, but it sketches why with probability 1, p(s) is a leaf for each $s\in(0,1)$, from which the result follows.

Random Maps 2 – The Schaeffer Bijection

As indicated at the end of the previous post, our aim is to find a natural bijection between the set of pointed, rooted quadrangulations with n faces, and some set of objects based on decorating rooted plane trees with n edges in some fashion. Unlike our previous example, the construction of this bijection is definitely not trivial. It seems like a foolish ambition to explain this without several pictures, so I’m going to focus on some aspects of the analysis which I found challenging, rather than the construction itself.

Anyway, we don’t yet know what the extended set of trees should be. We need an extra factor of $3^n$, so it is natural to consider adding some sort of labelling of the tree, where for each non-root vertex in turn there are three options. So, given a rooted tree T, we label the vertices such that the root has label 0, and if a parent vertex has label k, any offspring has label k-1, k or k+1. Such a labelling is called admissable, and $\mathbb{T}_n$ is the set of rooted plane trees with n edges and an admissable labelling.

We now demonstrate how to construct an element of $\mathcal{Q}_n$ from an element of $\mathbb{T}_n$. Various authors had considered this problem to various extents, and so what follows is known as the Cori-Vauquelin-Schaeffer bijection, at least in this course.

Consider a contour exploration of the tree. That is, start out at the root and at all times take first-edge you encounter going clockwise from your current direction. When you arrive at a leaf, you will indeed therefore immediately retrace your most recent step. The key property is that you traverse each edge exactly twice, and so we may think of the tree as having 2n oriented edges. It is more useful to think about corners. A corner is the directed arc (WLOG clockwise) between adjacent edges at a vertex. There is a natural bijection between corners and directed edges, by looking anti-clockwise from the tail of the edge. So the contour process explored the directed edges in some order, and hence explores the corners of the tree. One thing I found confusing initially was switching between considering vertices and corners. I feel in retrospect that the only reason we need the vertices themselves is to induce the labelling onto the corners. These are the only thing we will use in the construction.

As we trace out the contour process, naturally we see different labels. We define the successor of a corner with label k to be the next corner seen in the contour process (taken modulo 2n if necessary) with label k-1. Note that any corner on a vertex with minimal label will not have a successor. To counter this, we add a new vertex, suggestively called $v_*$, with a single corner (ie no edges yet) and denote this corner to be the successor of the corners in the original tree with minimal label.

To construct our quadrangulation, we simply join up every corner with its successor corner. Note that if you are thinking of the successor of a corner as a vertex (rather than as a corner) you will get in trouble here, as it might be several ways to draw this arc.

The red arcs and vertex v* are added to form the quadrangulation. Note the blue angles indicate the three corners around the vertex labelled -1.

It is not obvious that it is possible to do this so that the arcs do not overlap. However, by considering the label process as you explore via the contour process, it becomes clear that you can discount the possibility of any overlaps one by one. This applies equally to pairs of new arcs overlapping, as well as new arcs overlapping with edges of the original tree. In any case, we remove the edges of the original tree to obtain the quadrangulation.

Note that when you move from any corner of a vertex with label k to its successor, then to the successor of its successor and so on, the labels are decreasing, so eventually you must end up at a corner with minimal label, and hence at $v_*$. We conclude that the graph of arcs is connected. It remains to show that it is a quadrangulation.

This is rather fiddly to do without a diagram. Note first that whenever we have a directed edge in the tree going from label k to label k-1, then this edge essentially becomes an arc of the quadrangulation. We show that the edge oriented in the other direction, called say e, induces three further arcs of a quadrangle. So e goes from label k-1 to k. Consider the corners before and following e in the contour exploration, which is a corner around the vertex with label k. The successor of the corner after e is a corner with label k-1, and this has a successor with label k-2. By construction, this must also be the successor of the corner before e. Why? Well as we traverse the contour beyond e, the first appearance of label k-1 must happen before the first appearance of label k-2, as the increments can only be in {-1,0,1}. This gives us the three further arcs. Note also that the 2-colouring of the quadrangulation is given by the parity of the tree-labelling.

I was bothered about what happens if two vertices with label k-1 are in fact the same. This would happen if, for example, the vertex labelled k is a leaf. Then, at least two of the corners around the single vertex with label k-1 have the same corner as successor. A naïve attempt at drawing the resulting arcs did not give a quadrangle. The key observation is that you have to draw the arcs in the direction of the contour process. So in this case, the arc from the corner before edge e will loop all the way around the vertex with label k, so it contains the other two relevant arcs on its way to the vertex with label k-2, giving us the ‘pacman’ quadrangle discussed earlier.

The other case we have to check is when our base edge joins two vertices with label k. Then the other two vertices of the face will have label k-1. This is similar to the above, and slightly easier.

As a preliminary to checking that we can invert this construction, we observe that the vertices of the quadrangulation are the vertices of the original tree plus $v_*$, and furthermore, the labels in the tree are given by the graph distance from $v_*$ in the quadrangulation, with a constant added uniformly so that the root vertex has label 0.

At this point, we observe that in the construction, we didn’t specify how to choose the rooted edge of the quadrangulation. Canonically, we take it to be the arc between the first corner of the root in the contour process, and its successor. However, we can orient it in either direction, giving us the extra factor of 2 we were looking for.

Returning to the inverse, it is clear what to do when we see a quadrangle corresponding to the second case above – namely put an edge between the two vertices with label k. In the case where the face has labels {k,k-1,k-1,k-2} it is less obvious. Note though that by starting at the first corner of the root, which is identified by the rooted edge in the quadrangulation, we can recover the contour process from the arcs of the quadrangulation, and the labels. So when we see such a face, we can use this information to choose which of the (k-1)-labelled vertices to join to the vertex with label k.

Anyway, now we are convinced that this bijection works, the next stage is to apply it to gain extra information about a uniformly-chosen large quadrangulation. We can view the vertices as being those of a large uniform plane tree, and the labels as given by a random walk along this large tree. We might expect to see this labelling structure converge to something that looks like Brownian motion indexed by a Brownian continuum random tree, in a sense to be made more precise. And the labelling is not merely a decoration in the quadrangulation, since it specifies the distance to the identified point $v_*$. In particular, this gives a bound on the distance between any two vertices in the quadrangulation, eg two vertices chosen uniformly at random. In fact, by looking more carefully at the scaling limit of the uniform tree’s contour process, we can say rather more than that.

Random Maps 1 – Towards the Schaeffer Bijection

I have spent the past ten days in Saint Flour, an inaccessible but picturesque town in the rolling hills of Cantal, in the middle of France, and venue for perhaps the most notable summer school in probability. My highlight has been the course ‘Aspects of Random Maps’ delivered by Gregory Miermont, and I thought I should write a few posts about points of interest encountered during the lectures and private study.

A map is an embedding of a connected graph onto a surface. We typically do not care about the nature of this embedding up to homeomorphisms of the surface which preserve orientations of the map. One advantage for doing this is that the set of maps now might be countable, and the set of maps with n edges might be finite. This can be proved by considering a map to be obtained by glueing together polygonal faces. Some potential glueings are impossible, and some are equivalent, but for a fixed number of edges, the number of such sets of polygons and a possible glueing is finite. In fact we can be much more precise than this about how to describe precisely the legal glueing through a triple of permutations, but I won’t discuss this here.

I haven’t yet given a complete definition of a map. We want a typical large map, that is a map with a large number of vertices and edges, to be topologically roughly the same as the surface it is embedded into. In particular, the map needs to encode the geometric features of the surface. So a small triangle on the surface of a torus should not be considered a map. To rigorise this, we demand that any face of a map should be a topological disc, in particular, it should be simply connected. Since the torus itself is not simply connected, this excludes our triangle example. Note a single vertex on a torus is also excluded.

Although it goes against the usual order of definitions, it might be helpful to think of a map as an embedding which satisfies Euler’s formula: V – E + F = 2 -2g, where g is the genus of the surface. For a connected planar graph, induction is on the number of edges and vertices is the typical way to prove this result. The inductive step works the same on a more general surface, but it is less clear what the base case should be. Another consequence of the definition is that we should work on the sphere rather than the plane. From now on, this is our surface of interest.

We begin by considering $\mathcal{M}_n$ to be the family of rooted plane maps with n edges. The root is a distinguished oriented edge. Our aim is to count the size of this set.

Before doing this, we digress onto the topic of rooted plane trees. Note that any (rooted) tree in the classical sense is planar, but in a rooted plane tree, we also specify the geometric ordering of the offspring. For example, if the root has two offspring, of which one has precisely one offspring and the other has none, we consider these as two separate cases.

So now, if we denote by $a_k$ the number of plane trees with k edges, we can define a generating function via $A(z):=\sum_{k\ge 0} a_k z^k$. If the root vertex v has no offspring, this gives one possibility corresponding to k=0. Otherwise, there is a well-defined left-most offspring of the root, called u. Then u and its descendents form a plane tree, and v and its descendents apart from those through u also form a plane tree. So after accounting for the edge between u and v, we obtain

$A(z)=1+zA(z)^2,$

whenever A(z) is defined. We now can apply whichever is our favourite method of showing that this is the generating function of the Catalan numbers, $a_k=\frac{1}{k+1}\binom{2k}{k}$.

There is a more complicated version of this generating function argument due to Tutte that allows us to enumerate $\mathcal{M}_n$. It is convenient to work with a second variable in the generating function that encodes the degree of the root face. The resulting equation of generating functions is less well-known but using the Lagrange inversion formula gives the explicit expression

$|\mathcal{M}_n|=\frac{2}{n+2}\cdot \frac{3^n}{n+1}\binom{2n}{n}.$

Although there are extra terms, this motivates seeking a bijection between maps, and some version of rooted plane trees, perhaps decorated with some extra information. As in many cases, this will turn out to be possible. The bijection we end up with will not just help us enumerate the maps, but will also allow us to control a lot more information about distances in the map, which will be particularly useful when we try to take limits.

The first observation is that given a map, we can construct a dual map, by placing fresh vertices somewhere in the middle of each face, and joining a pair of these if the corresponding faces in the original graph share an edge.

Alternatively, we can place the same fresh vertices in the middle of each face, then join each new vertex to an original vertex, if that original vertex lies on the face corresponding to the new vertex. If you focus in on an original edge, it is clear that it is now surrounded by a ‘diamond’ (if you’ve drawn the diagram in a natural way) of new edges. Removing the original edges thus leaves us with a quadrangulation. This procedure is called the ‘trivial bijection’ between $\mathcal{M}_n$ and $\mathcal{Q}_n$, the family of rooted quadrangulations with n faces. Note that the root in such a quadrangulation is an identified directed edge, rather than a vertex. We haven’t yet specified how to describe the root of the resulting quadrangulation. It suffices to take the first new edge which lies clockwise of the root edge in the original graph, seen from the ‘tail’ of the root, which is of course oriented.

In this, and the bijections which follow, the natural questions to ask are: a) is the inverse obvious? and b) what happens to self-loops and isthmuses? Here, the inverse really is obvious. Any quadrangulation is bipartite, hence two-colourable, so we need to fix one colour and join the two vertices of that colour within each face to recover the original graph. The root tells us which colour we need to take. As for the second question, first we should say that an isthmus is an edge which has the same face on both sides. This causes no problems in this particular bijection. For the self-loops, we get a sort of Pacman-like quadrangle, with two ‘outer-edges’ between the same two vertices, and an edge between one of the outer vertices and some internal vertex. This edge contributes twice to the degree of the face.

The upshot of this is that for a simple enumeration, it suffices to prove that $|\mathcal{Q}_n|=\frac{2}{n+2}\cdot \frac{3^n}{n+1}\binom{2n}{n}$. This may not look like we have achieved much, but we can now apply Euler’s formula to any quadrangulation in this set to deduce that the number of vertices present is n+2. If we consider the set $\mathcal{Q}_n^*$, where now we identify a particular vertex $v_*$ in the quadrangulation, it suffices to prove that $|\mathcal{Q}_n^*|=2.3^n \cdot a_n$, where $a_n$ is the nth Catalan number as before. Now we have the most efficient setup to look for a bijection with some type of decorated plane tree as discussed before.


text:
# Data Science Posts and Resources

Articles on Data Science

## Single Layer Perceptron

A Single layer perceptron is a type of neuron having multiple inputs and one output. Input has many dimensions i.e input can be a vector for example input x = ( I1, I2, .., In). Input nodes are connected to a node in the next layer. The node in the next layer takes the weighted sum of all its inputs.

Laxmi K Soni

# Single Layer Perceptron

#### What is Single Layer Perceptron:

A Single layer perceptron is a type of neuron having multiple inputs and one output. Input has many dimensions i.e input can be a vector for example input x = ( I1, I2, .., In). Input nodes are connected to a node in the next layer. The node in the next layer takes the weighted sum of all its inputs.

for example input x = ( I1, I2, I3) = ( 5, 3.2, 0.1 )

$Summedinput = 5 w_1 + 3.2 w_2 + 0.1w_3$

The output node having a threshold t. If summed input ≥ threshold, then it outputs y = 1 else it output y = 0.

The single layer perceptron does not have a previous knowledge, therefore the initial weights are assign randomly. SLP adds all of the weighted inputs and if the addition is above the threshold (any predetermined value), SLP is known to be in the activated state i.e output=1.

The perceptron receives the input values and does calculations to find the predicted output. If the predicted output is the same as that of the expected output, then the performance is considered satisfactory and no changes to the weights are made. But, if the predicted output does not match the expected output, then the weights need to be adjusted to reduce the error.

#### The algorithm is

• Initially, assigning all the weights to some random values

• Repeating (for many epochs):

1. Feed the network with an input from one of the examples in the training set

2. Compute the error between the output of the network and the desired output

3. Correct the error by adjusting the weights of the nodes

• Until the error is very small

]

A single layer percepron is simplest form of network to solve a problem with step or linear activation functions.

#### Single Layer Perceptron for XNOR problem in R

library(neuralnet)
XOR <- c(0,1,1,0)
xor.data <- data.frame(expand.grid(c(0,1), c(0,1)), XOR)
print(xor.data)
print(net.xor <- neuralnet(XOR~Var1+Var2, xor.data, hidden=0, rep=5))
plot(net.xor, rep="best")
round(predict(net.xor, data.frame(xor.data)))

#### Implementing Single Layer Perceptron for XNOR problem in Python

import numpy as np
from keras.models import Sequential
from keras.layers.core import Dense

We import numpy and alias it as np

Keras offers two different APIs to construct a model: a functional and a sequential one. We’re using the sequential API hence the second import of Sequential from keras.models.

Neural networks consist of different layers where input data flows through and gets transformed on its way. There are a bunch of different layer types available in Keras. These different types of layer help us to model individual kinds of neural nets for various machine learning tasks. In our specific case the Dense layer is what we want.

# the four different states of the XOR gate
training_data = np.array([[0,0],[0,1],[1,0],[1,1]], "float32")

# the four expected results in the same order
target_data = np.array([[0],[1],[1],[0]], "float32")

We initialize training_data as a two-dimensional array (an array of arrays) where each of the inner arrays has exactly two items.

We setup target_data as another two-dimensional array. All the inner arrays in target_data contain just a single item though. Each inner array of training_data relates to its counterpart in target_data.

model = Sequential()
model.add(Dense(1, input_dim=2, activation='sigmoid'))

Sets up an empty model using the Sequential API. Add a Dense layer to our model in which We set input_dim=2 because each of our input samples is an array of length 2 ([0, 1], [1, 0] etc.). 1 stand the dimension of the output for this layer. Our model means that we have two input neurons (input_dim=2) spreading into 1 neuron in output layer without any hidden layer as we are trying to mimic a single layer perceptron.

model.compile(loss='mean_squared_error',
metrics=['binary_accuracy'])

]

With neural nets we always want to calculate a number (loss) that tells us how bad our model performs and then try to get that number lower. Mean_squared_error works as our loss function simply because it’s a well proven loss function. Then adam optimizer is usded to find the right adjustments for the weights. Last parameter metrics is the binary_accuracy which gives us access to a number that tells us exactly how accurate our predictions are.

model.fit(training_data, target_data, nb_epoch=500, verbose=2)

We kick off the training by calling model.fit(…) which require first two params, which are training and target data, the third one is the number of epochs (learning iterations), the last one tells keras how much info to print out during the training.

print(model.predict(training_data).round())

Using model.predict we can do predictions.

#### Summary:

McCulloch-Pitts neurons networks are computational devices, which are capable of performing any logical function. Single-Layer Perceptrons with step activation functions are constrained in what they can do. Adding additional hidden layers to the network will make it more powerful such that even non-linear relations can be predicted using such a neural network.

Nothing yet.

format: plain


text:
## M2-Team / FFmpegUniversal .gitee-modal { width: 500px !important; }

Explore and code with more than 6 million developers，Free private repositories ！：）
Notice: Creating folder will generate an empty file .keep, because not support in Git

# FFmpegUniversal

Merged FFmpeg dynamic linked library for the Windows Universal Platform.

## Prerequisites

Getting a compatible build of FFmpeg is required for this to work.

You can get the code for FFmpeg on Github yourself by cloning git://source.ffmpeg.org/ffmpeg.git.

Your FFmpegUniversal folder should look as follows

FFmpegUniversal\
FFmpeg\             - ffmpeg source code from the latest release in
git://github.com/FFmpeg/FFmpeg.git
FFmpegUniversal\    - FFmpegUniversal Generate WinRT DLL Project
FFmpegUniversalSDK\ - FFmpegUniversal Headers and DLL Project for
developer use.
FFmpegBuild.bat     - Helper script to build FFmpeg libraries as
described in
https://trac.ffmpeg.org/wiki/CompilationGuide/WinRT
FFmpegConfig.sh     - Internal script that contains FFmpeg configure
options
FFmpegCopy.bat      - Internal script to copy the appropriate builds of
FFmpeg libraries to the FFmpegUniversal project.
FFmpegUniversal.sln - Microsoft Visual Studio 2017 solution file
README.md

Now that you have the FFmpeg source code, you can follow the instructions on how to build FFmpeg for WinRT apps. Follow the setup instruction carefuly to avoid build issues. After completing the setup as instructed, you can invoke FFmpegBuild.bat script to build or do it manually using the instructions in the compilation guide after you modify the MSYS2_BIN variable in the FFmpegBuild.bat.

BuildFFmpeg.bat    - Build for Windows 10 ARM, x64, and x86

If you use the build script or follow the Wiki instructions as is you should find the appropriate builds of FFmpeg libraries in the Output/FFmpeg folders.

Simply open the FFmpegUniversal.sln and build the FFmpegUniversal, you will get the merged FFmpeg dynamic library for the Windows Universal Platform. Then, you copy the FFmpegUniversalSDK folder to your Visual Studio solution folder and add it to your solution and use "add reference" to add it to your project.

Finally, enjoy it.

Same as the FFmpeg, the default setting of FFmpeg compilation in FFmpegUniversal is distributed under the LGPL version 2.1 or later.

LGPL-2.1

No release


text:
# Welcome Hugo!

Porting to Hugo is successful.

print "Hello World!"

    digraph g {
node[shape="circle" , label="", width=0.2, height=0.2]
l1[xlabel="v$$s$$"]
l21[xlabel="a", width=0.1, height=0.1 , style=filled]
l22[width=0.1, height=0.1, style=filled]
l31[xlabel="v$$s'$$"]

l1 -> l21
l1 -> l22
l21 -> l31 [xlabel="r"]
l21 -> l32
l22 -> l33
l22 -> l34
}

$v_\pi(s) = \sum_{a \in \mathcal{A}} \pi(a|s) q_\pi(s,a)$

Some stuff still needs porting over, but it's functional. And much more sane than the prior routing schema. It's really slow, I don't get why the Posts route isn't highlighted, and the design is meh (and I didn't make it), but whatever. It's a good place to write and I think that's what I cared about in the first place.


text:
Number of submatrices with a particular sum- Answer Explantion

I read Evgeny Kluev answer on this and was not able to understand the mechanism. Now let us understand using an example. let us say we have this matrix.

[1  2  3  2   5,
2  4  6  4  10,
3  6  9  6  15,
2  4  6  4  10,
5  10 15 10 25]

Now applying step 1 we get .

[ 1  2  3  2  5 ,
3  6  9  6  15,
6  12 18 12 30,
8  16 24 16 40,
13 26 39 26 65]

Now applying step 2 we get all the possible pair of row indices i.e.

(1,2) (1,3) (1,4) (1,5) (2,3) (2,4) (2,5) (3,4) (3,5) (4,5)

Now comes the last part of applying two pointer algorithm. Which i am failing to understand.For ex.
Lets take (1,2)

B[2][1] - B[1][1]= 3-1 = 2
B[2][2] - B[1][2]= 6-2 = 4
B[2][3] - B[1][3]= 9-3 = 6
B[2][4] - B[1][4]= 6-2 = 4
B[2][5] - B[1][5]= 15-5 =10

Now how is that helping? I mean on these values if we apply two pointer algorithm what will we achieve? For example i am looking for all occurrences of 36. How do i get close to it. ?

Can anybody carry this forward and explain the solution?

The two-pointer algorithm is described in this post. Given a non-negative sequence $\alpha_1,\ldots,\alpha_n$ and a target sum $S$, we want to find the number of pairs $(i,j)$ such that $\alpha_i + \cdots + \alpha_j = S$. Let's make life a little easier by requiring the sequence to be strictly positive. For each $i$ there is therefore at most one $j$ such that $\alpha_i + \cdots + \alpha_j = S$, and we could find it by enumerating over all $j$ (resulting in an $O(n^2)$ algorithm) or using binary search (this requires $O(n)$ preprocessing, and leads to an $O(n\log n)$ algorithm).

The two-pointer algorithm is very similar but uses data from the $i$th iteration to make the $(i+1)$th iteration faster. Here is one variant For each $i$, we calculate the minimal index $j(i)$ such that $\alpha_i + \cdots + \alpha_{j(i)} \geq S$. The main observation is that $j(i)$ is a non-decreasing sequence, that is, $j(1) \leq \cdots \leq j(n)$. This suggests the following algorithm:

1. Initialize $j(0) = 0$.
2. For each $i$ in turn, calculate $j(i)$ by going over $j = j(i-1),j(i-1)+1,\cdots$ until $\alpha_i + \cdots + \alpha_j \geq S$. We then set $j(i) = j$. If $\alpha_i + \cdots + \alpha_{j(i)} = S$, we have found a subsequence summing to $S$.

This algorithm runs in linear time (basically since the index $j(i)$ keeps increasing) and finds all contiguous subsequences summing to $S$. I'll also let you figure out yourself what to do when some entries could be $0$.

• i am sorry but instead of talking in terms of J(0) and abstract explanation, could you explain with help of an example especially the second part. from the Two-pointer algorithm. Please excuse my n00bness. I am new to this. Apr 15 '15 at 21:41
• and also is my solution correct till here? i mean in taking the row pairs. if yes how do i know i have taken all possible sub matrices possible. Apr 15 '15 at 21:43
• It is a very important skill to be able to handle abstract explanations. The two-pointer algorithm is discussed in many webpages, and you can find pseudocode which you can program and trace to see what's going on. Apr 15 '15 at 21:49
• Regarding the first steps of the algorithm, it is really important that you understand what the algorithm is trying to do. The two-pointer algorithm used in the last step is really an optimization. Suppose that you implemented the last step using the trivial algorithm. Do you see why the algorithm then outputs the correct answer? If not, it is pointless trying to understand the tricky implementation of the last step. First understand the simpler aspects of the algorithm. Apr 15 '15 at 21:50
• Make sure that you understand first why the algorithm works at all (treating the two-pointer algorithm as a black box). Only then can you understand why the algorithm was designed this way. Apr 16 '15 at 19:18

As the values you have computed till now is array C[j] = summation of A[p][j] to A[q][j]. Now if we will be able to find the sub array C[x..y] with sum K then definitely sum of sub matrix A[p..q][x..y] will be K. In step 3 instead of applying two pointer algorithm, we can use this method for finding a sub array with given sum, which works in O(n).


text:
update another table afterinsert

Hi, relative newbie question:

I've got a datasheet form which I'm using for stock in/out recording
which adds a record for each stock transaction in a stock table (number
of stock in and out etc.) , I also have a total stock level field on the
products table - I want to add\subtract from the stock total in the
products table when I add a record to this stock transactions table in
the datasheet - what is the best method to do this? I was thinking do a
sql update in code on the Form_AfterInsert event - am I doing the right
thing?

--
Jyan
------------------------------------------------------------------------
Jyan's Profile: 557

[url="http://www.thecodecage.com"]Microsoft Office Help[/url]

 0
Jyan
12/29/2009 2:29:54 PM
access 16762 articles. 2 followers.

12 Replies
657 Views

Similar Articles

[PageSpeed] 46

Rather than using a calculated field, which is not normalized database
behavior and prone to error as well. Why don't you use a query with a
calculated column:

Calculation: DSum("StockIn", "TableName") - DSum("StockOut", "TableName")
--
Arvin Meyer, MCP, MVP
http://www.datastrat.com
http://www.mvps.org/access
http://www.accessmvp.com

"Jyan" <Jyan.43ymqk@thecodecage.com> wrote in message
news:Jyan.43ymqk@thecodecage.com...
>
> Hi, relative newbie question:
>
> I've got a datasheet form which I'm using for stock in/out recording
> which adds a record for each stock transaction in a stock table (number
> of stock in and out etc.) , I also have a total stock level field on the
> products table - I want to add\subtract from the stock total in the
> products table when I add a record to this stock transactions table in
> the datasheet - what is the best method to do this? I was thinking do a
> sql update in code on the Form_AfterInsert event - am I doing the right
> thing?
>
>
> --
> Jyan
> ------------------------------------------------------------------------
> Jyan's Profile: 557
>
> [url="http://www.thecodecage.com"]Microsoft Office Help[/url]
>

 0
Arvin
12/29/2009 3:04:24 PM
Do you mean run an update query to update the stock total column in the
products table using the calculation shown?

'Arvin Meyer [MVP Wrote:
> ;597682']Rather than using a calculated field, which is not normalized
> database
> behavior and prone to error as well. Why don't you use a query with a
> calculated column:
>
> Calculation: DSum("StockIn", "TableName") - DSum("StockOut",
> "TableName")
> --
> Arvin Meyer, MCP, MVP
> 'DataStrat - Data Strategies - The DataStrat Solution'
> (http://www.datastrat.com)
> 'The Access Web - Welcome' (http://www.mvps.org/access)
> 'Access MVPs' (http://www.accessmvp.com)
>
>
> "Jyan" <Jyan.43ymqk@thecodecage.com> wrote in message
> news:Jyan.43ymqk@thecodecage.com...
> >
> > Hi, relative newbie question:
> >
> > I've got a datasheet form which I'm using for stock in/out recording
> > which adds a record for each stock transaction in a stock table
> (number
> > of stock in and out etc.) , I also have a total stock level field on
> the
> > products table - I want to add\subtract from the stock total in the
> > products table when I add a record to this stock transactions table
> in
> > the datasheet - what is the best method to do this? I was thinking do
> a
> > sql update in code on the Form_AfterInsert event - am I doing the
> right
> > thing?
> >
> >
> > --
> > Jyan
> >
> ------------------------------------------------------------------------
> > Jyan's Profile: 557
> > 'update another table afterinsert - The Code Cage Forums'
> >
> > 'Microsoft Office Help' ("http://www.thecodecage.com")
> >

--
Jyan
------------------------------------------------------------------------
Jyan's Profile: 557

[url="http://www.thecodecage.com"]Microsoft Office Help[/url]

 0
Jyan
12/29/2009 3:30:08 PM
No, you do not need to store the stock total, ever. You can always calculate
it in a query, form, or report.
--
Arvin Meyer, MCP, MVP
http://www.datastrat.com
http://www.mvps.org/access
http://www.accessmvp.com

"Jyan" <Jyan.43yq93@thecodecage.com> wrote in message
news:Jyan.43yq93@thecodecage.com...
>
> Do you mean run an update query to update the stock total column in the
> products table using the calculation shown?
>
>
> 'Arvin Meyer [MVP Wrote:
>> ;597682']Rather than using a calculated field, which is not normalized
>> database
>> behavior and prone to error as well. Why don't you use a query with a
>> calculated column:
>>
>> Calculation: DSum("StockIn", "TableName") - DSum("StockOut",
>> "TableName")
>> --
>> Arvin Meyer, MCP, MVP
>> 'DataStrat - Data Strategies - The DataStrat Solution'
>> (http://www.datastrat.com)
>> 'The Access Web - Welcome' (http://www.mvps.org/access)
>> 'Access MVPs' (http://www.accessmvp.com)
>>
>>
>> "Jyan" <Jyan.43ymqk@thecodecage.com> wrote in message
>> news:Jyan.43ymqk@thecodecage.com...
>> >
>> > Hi, relative newbie question:
>> >
>> > I've got a datasheet form which I'm using for stock in/out recording
>> > which adds a record for each stock transaction in a stock table
>> (number
>> > of stock in and out etc.) , I also have a total stock level field on
>> the
>> > products table - I want to add\subtract from the stock total in the
>> > products table when I add a record to this stock transactions table
>> in
>> > the datasheet - what is the best method to do this? I was thinking do
>> a
>> > sql update in code on the Form_AfterInsert event - am I doing the
>> right
>> > thing?
>> >
>> >
>> > --
>> > Jyan
>> >
>> ------------------------------------------------------------------------
>> > Jyan's Profile: 557
>> > 'update another table afterinsert - The Code Cage Forums'
>> >
>> > 'Microsoft Office Help' ("http://www.thecodecage.com")
>> >
>
>
> --
> Jyan
> ------------------------------------------------------------------------
> Jyan's Profile: 557
>
> [url="http://www.thecodecage.com"]Microsoft Office Help[/url]
>

 0
Arvin
12/29/2009 4:27:04 PM
Ah yes now I see! Many thanks for the advice.

'Arvin Meyer [MVP Wrote:
> ;597777']No, you do not need to store the stock total, ever. You can
> always calculate
> it in a query, form, or report.
> --
> Arvin Meyer, MCP, MVP
> 'DataStrat - Data Strategies - The DataStrat Solution'
> (http://www.datastrat.com)
> 'The Access Web - Welcome' (http://www.mvps.org/access)
> 'Access MVPs' (http://www.accessmvp.com)
>
>
> "Jyan" <Jyan.43yq93@thecodecage.com> wrote in message
> news:Jyan.43yq93@thecodecage.com...
> >
> > Do you mean run an update query to update the stock total column in
> the
> > products table using the calculation shown?
> >
> >
> > 'Arvin Meyer [MVP Wrote:
> >> ;597682']Rather than using a calculated field, which is not
> normalized
> >> database
> >> behavior and prone to error as well. Why don't you use a query with
> a
> >> calculated column:
> >>
> >> Calculation: DSum("StockIn", "TableName") - DSum("StockOut",
> >> "TableName")
> >> --
> >> Arvin Meyer, MCP, MVP
> >> 'DataStrat - Data Strategies - The DataStrat Solution'
> >> ('DataStrat - Data Strategies - The DataStrat Solution'
> (http://www.datastrat.com))
> >> 'The Access Web - Welcome' ('The Access Web - Welcome'
> (http://www.mvps.org/access))
> >> 'Access MVPs' ('Access MVPs' (http://www.accessmvp.com))
> >>
> >>
> >> "Jyan" <Jyan.43ymqk@thecodecage.com> wrote in message
> >> news:Jyan.43ymqk@thecodecage.com...
> >> >
> >> > Hi, relative newbie question:
> >> >
> >> > I've got a datasheet form which I'm using for stock in/out
> recording
> >> > which adds a record for each stock transaction in a stock table
> >> (number
> >> > of stock in and out etc.) , I also have a total stock level field
> on
> >> the
> >> > products table - I want to add\subtract from the stock total in
> the
> >> > products table when I add a record to this stock transactions
> table
> >> in
> >> > the datasheet - what is the best method to do this? I was thinking
> do
> >> a
> >> > sql update in code on the Form_AfterInsert event - am I doing the
> >> right
> >> > thing?
> >> >
> >> >
> >> > --
> >> > Jyan
> >> >
> >>
> ------------------------------------------------------------------------
> >> > Jyan's Profile: 557
> >> > View this thread:
> >> > 'update another table afterinsert - The Code Cage Forums'
> >> ('update another table afterinsert - The Code Cage Forums'
> >> >
> >> > 'Microsoft Office Help' ("http://www.thecodecage.com")
> >> >
> >
> >
> > --
> > Jyan
> >
> ------------------------------------------------------------------------
> > Jyan's Profile: 557
> > 'update another table afterinsert - The Code Cage Forums'
> >
> > 'Microsoft Office Help' ("http://www.thecodecage.com")
> >

--
Jyan
------------------------------------------------------------------------
Jyan's Profile: 557

[url="http://www.thecodecage.com"]Microsoft Office Help[/url]

 0
Jyan
12/29/2009 5:03:02 PM
Any thoughts on my last post anyone?

--
Jyan
------------------------------------------------------------------------
Jyan's Profile: 557

[url="http://www.thecodecage.com"]Microsoft Office Help[/url]

 0
Jyan
12/30/2009 10:39:29 AM
Jya:

Lets assume your products table has a numeric primary key column ProductID,
which is referenced by the stock table with a foreign key column, also
ProductID.  What you need to do is sum the StockIn values less the StockOut
values for each product.  You can do this as a computed column in a query
based on the products table, or in a computed control on a form or report
based on the same table.  In either case the expression would be the same
(all on one line):

Nz(DSum("Nz([StockIn],0) - Nz([StockOut],0)", "[StockTable]", "[ProductID] =
" & [ProductID]),0)

The Nz function is used here to take account of Nulls as, if there are no in
or out transactions for a particular product, then the DSum function would
return a Null.  Also if there is a StockIn value for a product but its
StockOut value is Null then subtracting Null from the StockIn value would
return Null, not the StockIn value.  The Nz function returns a zero in place
of a Null, so the result will be correct in all cases.

By computing the balance of stock per product from the stock movements in
this way you are always guaranteed that the figure accurately reflects the
stock movements, so you can dispense with the stock level field in the
products table.  Having such a field merely introduces redundancy, which in a
relational database is 'a bad thing' as it leaves the door open to
inconsistent data, there being no guarantee that its values and the StockIn
and StockOut values per product will tally.

You could if you wished also include a computed control using the above
expression in a form based on the stock table; it would show the balance of
stock in hand  for whatever product is the subject of the stock movement in
question.  When entering a new stock movement record it would not update of
course until the record is saved as its summing the values in the saved
records in the underlying table, so the form's current record is not included
in the sum until it is saved to the table.

Ken Sheridan
Stafford, England

Jyan wrote:
>Any thoughts on my last post anyone
>
>--
>Jya
>-----------------------------------------------------------------------
>Jyan's Profile: 55
>
>[url="http://www.thecodecage.com"]Microsoft Office Help[/url

--
Message posted via AccessMonster.com
http://www.accessmonster.com/Uwe/Forums.aspx/access/200912/1

 0
KenSheridan
12/30/2009 5:21:37 PM
Your last post read: "Ah yes now I see! Many thanks for the advice."

What kind of thoughts were you expecting anyone to have about that?  I
thought it was polite and courteous.

If you are asking for a detail answer to some earlier technical question,
you need to be more explicit.

Larry Linson
Microsoft Office Access MVP

"Jyan" <Jyan.4406nx@thecodecage.com> wrote in message
news:Jyan.4406nx@thecodecage.com...
>
> Any thoughts on my last post anyone?

 0
Larry
12/30/2009 6:20:58 PM
merci a tous meme les inconnus
"Jyan" <Jyan.43ymqk@thecodecage.com> a �crit dans le message de
news:Jyan.43ymqk@thecodecage.com...
>
> Hi, relative newbie question:
>
> I've got a datasheet form which I'm using for stock in/out recording
> which adds a record for each stock transaction in a stock table (number
> of stock in and out etc.) , I also have a total stock level field on the
> products table - I want to add\subtract from the stock total in the
> products table when I add a record to this stock transactions table in
> the datasheet - what is the best method to do this? I was thinking do a
> sql update in code on the Form_AfterInsert event - am I doing the right
> thing?
>
>
> --
> Jyan
> ------------------------------------------------------------------------
> Jyan's Profile: 557
>
> [url="http://www.thecodecage.com"]Microsoft Office Help[/url]
>

 0
didier
1/17/2010 10:49:00 AM
Sorry? What am I supposed to have done wrong? :confused:

Larry Linson;598815 Wrote:
>
> What kind of thoughts were you expecting anyone to have about that?  I
> thought it was polite and courteous.
>
> If you are asking for a detail answer to some earlier technical
> question,
> you need to be more explicit.
>
> Larry Linson
> Microsoft Office Access MVP
>
> "Jyan" <Jyan.4406nx@thecodecage.com> wrote in message
> news:Jyan.4406nx@thecodecage.com...
> >
> > Any thoughts on my last post anyone?

--
Jyan
------------------------------------------------------------------------
Jyan's Profile: 557

[url="http://www.thecodecage.com"]Microsoft Office Help[/url]

 0
Jyan
1/17/2010 4:20:33 PM
Jya:

Its just that we are also a little confused as to whether there are any
outstanding points on which you need advice.  You asked for any views on your
'last post', but the post previous to that simply expressed thanks (which was
good of you) but didn't ask any further questions.

I tried to address the issue in general terms, but we are not sure whether
you need anything further from us or not.

Ken Sheridan
Stafford, England

Jyan wrote:
>Sorry? What am I supposed to have done wrong? :confused:
>
>Larry Linson;598815 Wrote:
>>
>[quoted text clipped - 9 lines]
>>
>> > Any thoughts on my last post anyone
>
>--
>Jya
>-----------------------------------------------------------------------
>Jyan's Profile: 55
>
>[url="http://www.thecodecage.com"]Microsoft Office Help[/url

--
Message posted via http://www.accessmonster.com

 0
KenSheridan
1/17/2010 5:21:35 PM
Actually if everyone looks carefully in the thread you see the following

-OK I've got the following query which adds all the Stock In per
product: SELECT DISTINCT DSum("[Quantity]","[Stock Levels]","[Product] =
" & [Product]) AS [Total Stock In], [Stock Levels].Product
FROM Products INNER JOIN [Stock Levels] ON Products.[Product ID] =
[Stock Levels].Product
WHERE ((([Stock Levels].[Stock In \ Stock Out])="In"));

I can't now figure out how to subtract the sum of the records in the
same query [Stock In \ Stock Out]="Out" and what to do if there is no
record (ie make it a zero for the sum to work). Also would it be better
to have a separate Stock In and Stock Out column?-

KenSheridan via AccessMonster.com;615081 Wrote:
> Jya:
>
> Its just that we are also a little confused as to whether there are
> any
> outstanding points on which you need advice.  You asked for any views
> on your
> 'last post', but the post previous to that simply expressed thanks
> (which was
> good of you) but didn't ask any further questions.
>
> I tried to address the issue in general terms, but we are not sure
> whether
> you need anything further from us or not.
>
> Ken Sheridan
> Stafford, England
>
> Jyan wrote:
> >Sorry? What am I supposed to have done wrong? :confused:
> >
> >Larry Linson;598815 Wrote:
> >> Your last post read: "Ah yes now I see! Many thanks for the
> >>
> >> d text clipped - 9 lines Wrote:
> >
> > >>
> > >> > Any thoughts on my last post anyone
> > >
> > >--
> > >Jya
> > >-----------------------------------------------------------------------
> > >Jyan's Profile: 55
> > >View this thread: 'ProgressBar Control - The Code Cage Forums'
> > >
> > >[url="http://www.thecodecage.com"]Microsoft Office
> > Help[/url
> >
> > --
> > Message posted via http://www.accessmonster.com> >

--
Jyan
------------------------------------------------------------------------
Jyan's Profile: 557

[url="http://www.thecodecage.com"]Microsoft Office Help[/url]

 0
Jyan
1/17/2010 6:01:48 PM
Jya:

That doesn't appear anywhere previously in the thread as I'm seeing it, which
explains the confusion.  Anyway, it looks like you have a single Quantity
column for stock movements both in and out and a column Stock In \ Stock Out
which indicates the type of transaction.  In which case to get the balance of
stock you need to sum the values of Quantity multiplied by 1 or -1 depending
on whether the stock movement is in or out, which you can do by calling the
IIf function like so:

DSum("[Quantity] * IIf([Stock In \ Stock Out] =""In"",1,-1)", "[Stock Levels]
", "[Product] = " & [Product])

Note the pairs of contiguous quotes to represent literal quotes characters
within a string expression.

However, you'd normally do this by grouping a query:

SELECT Product,
SUM(Quantity * IIf([Stock In \ Stock Out] ="In",1,-1)) AS Balance
FROM [Stock Levels]
GROUP BY Product;

Having separate stock in and stock out columns would not really make any
material difference.

Ken Sheridan
Stafford, England

Jyan wrote:
>Actually if everyone looks carefully in the thread you see the followin
>
>-OK I've got the following query which adds all the Stock In pe
>product: SELECT DISTINCT DSum("[Quantity]","[Stock Levels]","[Product]
>" & [Product]) AS [Total Stock In], [Stock Levels].Product
>FROM Products INNER JOIN [Stock Levels] ON Products.[Product ID]
>[Stock Levels].Product
>WHERE ((([Stock Levels].[Stock In \ Stock Out])="In"));
>
>I can't now figure out how to subtract the sum of the records in th
>same query [Stock In \ Stock Out]="Out" and what to do if there is n
>record (ie make it a zero for the sum to work). Also would it be bette
>to have a separate Stock In and Stock Out column?-
>
>KenSheridan via AccessMonster.com;615081 Wrote:
>> Jya:
>>
>[quoted text clipped - 35 lines]
>> > --
>> > Message posted via http://www.accessmonster.com>
>
>--
>Jya
>-----------------------------------------------------------------------
>Jyan's Profile: 55
>
>[url="http://www.thecodecage.com"]Microsoft Office Help[/url

--
Message posted via AccessMonster.com
http://www.accessmonster.com/Uwe/Forums.aspx/access/201001/1

 0
KenSheridan
1/17/2010 11:40:58 PM

Similar Artilces:

Error: Can't clean up the following tables: PriceLevel. 02-13-05
Hello all, using CRM 1.2 on a win2k3 server we get this error in the application event log: Source: MSCRMDeletionService Event ID: 5895 - Error: Can't clean up the following tables: PriceLevel. Category: none User: n/a Computer: our_exchange_server ooppps, I forgot, of course many thanks in advance for any tip! ...

updating sheets based on data in first sheet
Another payroll question, I have a workbook that contains 26 sheets, one for each bi-weekl payroll period. I would like to set it up so when i add a new employe the rest of the sheets also update automatically with that employee name and information. I have been able to acheive this to a limited degree using th =sheet1!a1 formula, but this only updates the info in the first cel and particularly the first column. I would like to acheive this using the first sheet, since at th end of the year I would like to be able to calculate ytd figure easily. Thank -- Message posted from http://www.Exc...

Update for MS Money 2005?
I have Money 2005. Is there an update to MS Money for Canadian users? Thanks in advance for any answers. We need a bit more information! Are you having problems with M2005 or is this just a post-Christmas/New Year random query when you are trying to get away from the in-laws? -- Regards Bob Peel, Microsoft MVP - Money For unofficial FAQs see http://money.mvps.org/ or http://umpmfaq.info/ I do not respond to any emails that I have not specifically asked for. "Daniel" <Daniel@discussions.microsoft.com> wrote in message news:E86EAB89-21DE-4505-ACAD-647278D736BD@microso...

pivot table with dynamic base data
hiya, im trying to create a pivot table where I can change my base data (inserting or deleting rows of data) and still have this reflected in the pivot table. My solution was to use entire columns as my range for input to the pivotTable, but this means including blank rows which seems to muck up the calculations. I cant think how else i can allow for new rows to be added to the base data anyone got any ideas how to do this? thanks loads for your help! You can use a dynamic range as the source. There are instructions here: http://www.contextures.com/xlPivot01.html bb wrote: > hiy...

Problem with Script Updating
I am using a script to update the “1099 Type” field for Master Vendor table. The script basically is a basic if-then statement. This script is run “Before Document Commit” and it’s not updating correctly, its flip-flopping the results. When the script is set to run Before Document Commit I have the “Destination mapping” field “1099 Type” set to “Use Script”. Script below: If SourceFields("Send 1099") = "N" Then DestinationFields("Options.1099 Type").Value = 1 Else DestinationFields("Options.1099 Type").Value = 4 End If I have also tried this s...

Excel 2010 Slicer Connection / Pivot Table Problem
Working in Excel 2010 beta. I have two pivot tables created from different SSAS cubes. I have PowerPivot add in installed, but not using it for this project. The two pivot tables both share several similar dimensions. When I try to connect a given slicer to both pivot tables, the 2nd pivot table is not available in the "Pivot Table Connections" window. The only pivot table listed in the "Pivot Table Connections" is the one for which the slicer was originally created. All of the posts I've seen so far say that all the pivot tables in the workbook should appear...

Microsoft Update only updates Windows Defender
iacrosoft Update only updates Windows Defender - I have to use Belarc Advisor to get a list of missing updates, and then go to the Microsoft Download Center to search for the missing updates and download and install them one at a time. I have Windows XP Home SP3, with Microsoft Update set to automatic download - can anyone tell me why I do not get all the necessary upadtes? Is this a sudden, new problem? When was Automatic Updates last working? Can you update manually via http://windowsupdate.microsoft.com? Any chance you've got a beta build of WinXP SP3 installed? What...

I created a newsletter yesterday - everything fine - use Publisher all the time. Then an automatic update came down this morning and I can't open the file - it says "Publisher cannot open file" Other documents in Publisher are opening - any ideas? http://support.microsoft.com/kb/972566/ -- JoAnn Paules MVP Microsoft [Publisher] Tech Editor for "Microsoft Publisher 2007 For Dummies" "Kim" <Kim@discussions.microsoft.com> wrote in message news:8754339B-99DC-4D09-83AD-6B34D8215274@microsoft.com... >I created a newsletter yesterday - everythin...

From temporary table to master table and then join this in junction table
Hello, I have imported two spreadsheets from excel to two temporary tables called "import_tbl_contract" and "import_tbl_products". I do this on daily basis and import many spreadsheets. I end up with these data: [import_tbl_contract] contract_number contract_title start_date end_date [import_tbl_products] product_number product_text price I now append these data to the following two tables: [tbl_contract] contract_id (PK) contract_title start_date end_date e.g. 1; Syringes and needles; 01-01-2010; 31-12-2010 [tbl_products] product_id ...

Update question
Soory if this is the wrong place to ask this, but cannot find a NG proper to Windows 7. I currently run Windows Vista and am getting tired of Vista's decision to tell me that it is going to shut down in less than a minute. So have decided to upgrade to Windows &. I note that I can purchase an upgrade versiom for 64 quid from Amazon or an apparently full version of Windows 7 Home premium for 89 quid. My question is this - If I buy the upgrade version will I only be able to load it on a new PC in the future if I already have windows Vista installed? i.e For any future cl...

Outlook 2003 died mysteriously after update
Setup in a nutshell... System: Lenovo T500 laptop OS: Vista Business SP1 32-bit Software: Office Outlook 2003 SP3 Problem... So I'm using this setup for over a year, everything OK. Yesterday I did two things and now Outlook dies (quietly, sans error message) immediately after startup. It show the splash screen, displays my inbox, and *poof* disappears. What I did earlier... 1. Windows Update installed: KB9766662, KB979306, KB979099, KB975929 2. At the same time, while searching for another program to uninstall I stumbled upon (and uninstalled) Windows LIVE Toolbar and...

How update entity in post update?
I created a handler for Update post callout for Opportunity. I want update some fields of the opportunity on the PostUpdate. However, if I call the Update method of CRMOpportunity in the PostUpdate I will create a recursive post callout. Can somebody help me? Thank you for pay attention []'s Vin�cius Pitta Lima de Ara�jo You need to check the OrigObjectXML field to see what fields were updated and then act appropriately. Matt Parks MVP - Microsoft CRM ---------------------------------------- ---------------------------------------- On Wed, 4 Aug 2004 17:43:17 -0300, "Vin�cius ...

Cannot install update KB979906 for .NET Framework 1.1 SP1
Running : Windows XP media center edition SP3 Have tried installing KB979906 a few times and also downloaded update manually but cannot install this update. Receiving error 0x643.Is it safe to uninstall the .NET Framework 1.1 and re-install as possibly corrupt , without having to uninstall/re-install all other .NET frameworks 2 , 3 and 3.5 including the updates that go with them? .. Hello sherlockomes, you might want to look at the following kb article to see if this will help with the error 80070643. <http://windows.microsoft.com/en-US/windows-vista/Windows-Update-error...

Print record once, update Yes/No field verifiying print
I would like to print a group of records, then have a Yes/No field [Printed] updated in my Jobs table with an update query showing the records were printed. Then next time the report runs, In my query criteria I will test for True values on the Yes/No field. Then only the records with the Yes/No field marked No will print. Any suggestions? Thanks Tommyboy,there's more to this question than meets the eye. For an explanation of what's involved, see: Has the record been printed? at: http://allenbrowne.com/ser-72.html The article includes a free sample database that dem...

latest update too MSCFV2
Hi, I have MSCFV2 version 6.5.7825.0. Could someone inform me if this is the latest download? Looks like you have 6.5.7825.0 from 05/21/2006, but there is a newer version - 6.5.7831.0 from 06/01/2006. C. Smith Enso Technologies, Incorporated http://www.ensotech.com On Tue, 13 Jun 2006 04:25:02 -0700, Paul <Paul@discussions.microsoft.com> wrote: >Hi, > >I have MSCFV2 version 6.5.7825.0. Could someone inform me if this is the >latest download? Christopher Smith csmith@ensotech.com Enso Technologies, Incorporated http://www.ensotech.com Also - meant to post this in t...

Hi All, I need to update a menu item dynamically, setting its SetCheck property to either true or false, based on a user operation. I am trying to do this from a custom function. Usually, the pCmdUI pointer is used. But how do I do it from another function? Thanks Your "other function" should change some setting. In your ON_UPDATE_COMMAND_UI handler, you should check that setting and call SetCheck as needed. -------------- Ajay Kalra ajaykalra@yahoo.com In addition to Ajay's response, this page may help you: http://msdn2.microsoft.com/en-us/library/6kc4d8f...

How to call another file in your xml document.
Greetings. I have an app which calls "text.xml", which is stored on a network share. Each user has different text requirements. what I want is for "text.xml" which is stored on the network, to read a file locally on the user's macine (i.e. c:\localtext\text.txt) and populate it with the local contents and display it. So for each user the content would be customized to his liking. Please let me know if this is possible and if so, how. Thank You Hemang "Hemang Shah" <v-hshah@microsoft.com> wrote: > Please let me know if this is possible and if...

Money gets its updates from spcomstock.com and the server has moved to a new site. The default site that money provides has to be changed. At this time I don't know how to do this. If I find out how to do this I will Post it. ...

Searching database for name of table or parts thereof?
Hi there, I have about 50 tables in my Access database. As you can imagine, it can be difficult to find specific tables. I would like to search all the tables for a table name or parts thereof. How can I do that? I looked for it, but could not come up with an approach. Thank you for your help. On Mar 3, 4:14=A0pm, FSPH <F...@discussions.microsoft.com> wrote: > I have about 50 tables in my Access database. As you can imagine, it can b= e > difficult to find specific tables. I would like to search all the tables f= or > a table name or parts thereof. http://databases.aspfa...

Payroll Update
HI all, We are running GP 7.5. I installed SP7 and the July 2005 tax update for CDN payroll. Now out payroll administrator gets an error message: 'The modified version of P_Payroll registry is missing'. How do I fix this problem Thanks -- Henry ...

RE: Moving a Mailbox from Storage group to another SG
Hello's I'm trying to move mailboxes from one Storage group to another on the same server. I have tried using Exchange Tasks to move the mailbox. However, Exchange Tasks fails the job due to what it says are errors. I have tried using Exmerge to create a PST of the mailbox, but still need the mailbox present in the destination SG to import the PST into the mailbox. Please advice on how to perform this task. thanks Blue. are the accounts enabled? is it perhaps a "storage limit" issue? -- Susan Conkey [MVP] "Bluehades" <Bluehades@discussions.microsoft....

Multiple Pivot Tables?
Am I able to have two different pivot tables in the same worksheet? What I am doing is I made a timesheet and we have one pivot table that counts up the Service Type and sums the Time. I now want a separate pivot table that will give me the Job Number and the total time associated with that particular job. I can't seem to figure this out. Any help is greatly appreciated. THANK YOU! ...

[ANN] Excel X security update
Hi All, A security update for Excel X was also released today: http://www.microsoft.com/mac/downloads.aspx?pid=download&location=/mac/d ownload/officex/ExcelX_Security_1017.xml&secid=5&ssid=17&flgnosysreq=Tru e Or at least: http://www.microsoft.com/mac/downloads.aspx Corentin -- --- Mac:MS MVP (Francophone) --- http://www.mvps.org - http://mvp.support.microsoft.com MVPs are not MS employees - Les MVP ne travaillent pas pour MS Remove "NoSpam" to e-mail me - Retirez "NoSpam" pour m'�crire ...

Microsoft, can we get an update on the login issue please???? It's been a whole day since we heard from Russ last. Err, Russ sent 2 updates today. Subject line = "File Lock Update" Hope you can find them. "shan" <anonymous@discussions.microsoft.com> wrote in message news:6bef01c475b3$3e7d6ea0$a601280a@phx.gbl... > Microsoft, can we get an update on the login issue > please???? It's been a whole day since we heard from > Russ last. >-----Original Message----- Look again, he posted 2 yesterday, we are still waiting for something today...


text:
There was recently a question on r/ProgrammingLanguages about error handling strategies in a compiler.

The more correct errors a compiler can produce, the better for a language where compile times are long. On the other hand false positives are not helping anyone.

In my case, the language compiles fast enough, so my focus has been to avoid false positives. I use the following rules:

1. Lexing errors: these are handed over to the parser creating parser errors.
2. Parsing errors: skip forward until there is some token it is possible to safely sync on.
3. Parser sync: some tokens will always be the start of a top level statement in my language: struct, import, module. Those are safe to use. For some other token types indentation can help: for example in C3 fn is a good sync token if it appears at zero indentation, but if it's found further in, it's likely part of a function type declaration: define Foo = fn void();. Only sync on tokens you are really sure of.
4. No semantic analysis for code that doesn't parse: code that doesn't parse are very unlikely to semantically analyse. Pessimistic parser sync means lots of valid code may get skipped, making semantic analysis fail even though the code might pass.
5. Use poisoning during semantic analysis. I saw this first described by Walter Bright, the creator of the D-Language. It is simple and incredibly effective in avoiding incorrect error reporting during semantic analysis. The algorithm is simply this: if an AST-node has an error, report it and mark it as poisoned. Then proceed to mark the parent of this AST-node poisoned as well, stopping any further analysis of the node (but without reporting any further errors).

I don't do anything particularly clever in regards to error reporting, but I found that these rules are sufficient to give very robust and correct error handling.


text:
# Forecasting Pseudo Random Numbers Using Deep Learning

Publisher: IEEE

Abstract:Software algorithms are incapable of generating truly random numbers. Algorithmic pseudo random number generators (PRNG’s) are used instead. Any pure randomness, like ini...View more
Abstract:
Software algorithms are incapable of generating truly random numbers. Algorithmic pseudo random number generators (PRNG’s) are used instead. Any pure randomness, like initiating a random seed, requires a query external to the PRNG algorithm. Is it possible for deep learning to mimic the performance of a PRNG algorithm using a generated string of numbers for training? There are at least two approaches to doing this. In the first, a class of parameterized PRNG’s is assumed a priori and learning consists of identification the PRNG parameters. The second approach is nonparametric and makes no model assumption. It seeks to forecast subsequent pseudo random numbers learned solely from a string of numbers generated by the PRNG. Our approach closely resembles the latter. We show that learning the sequence of a variation of the linear congruential generator random number generator to a good approximation is possible using neural network deep learning.
Date of Conference: 13-15 Dec. 2021
Date Added to IEEE Xplore: 30 December 2021
ISBN Information:
Publisher: IEEE
Conference Location: Sydney, Australia
2.
Quantum random number generators can be purchased at Amazon.com and are available on line. See. e.g., ANU QRNG: Quantum random numbers, https://qrng.anu.edu.au/random-hex/
3.
The Linux documentation of the dieharder package can be found on https://linux.die.net/man/l/dieharder .
4.
See, e.g. IDQ’s commercially available quantum devices for use in gaming and other areas. https://www.idquantique.com/

SECTION I.

## Introduction

True random numbers cannot be generated algorithmically [1]. True (nonalgorithmic) random numbers are generated in quantum mechanics in the process of radioactive decay. 2

Pseudo random number generators (PRNG), algorithms that simulate randomness, are implemented for many applications. They are used to generate random numbers, even though they are deterministic in nature. When used in electronic gaming, the performance of a PRNG requires passing performance hurdles [2] such as those in the Die Hard battery of randomness tests [3] available in the software package Dieharder. 3

Besides randomness, PRNG’s must be difficult to invert. Otherwise, future numbers can easily be derived from past numbers. The more difficult the inversion, the better. However, the current PRNG’s are generated from deterministic models specified by a few lines of code. In theory, the algorithm can be discovered or at least mimicked given a sufficiently long string of numbers generated by the PRNG. In practice, this is very difficult to do, but it is possible to get a good approximation. Instantiations, like cryptographically secure PRNG [5], require high security scrutiny [6], [7]. The work described in this article presents an experimental approximation of the predictions of a PRNG from raw data. There are at least two approaches to characterizing a PRNG. The first approach assumes a priori a class of parameterized PRNG’s. The learning includes identifying the PRNG parameters. The second approach is nonparametric and it makes no assumption about the model. It seeks to forecast subsequent pseudo random numbers learned solely from a string of numbers generated by the PRNG. Similar to the latter, our method only assumes that the PRNG is a first-order Markov process. Only the latest results of the PRNG are used to calculate the next one [8], [9].

SECTION II.

## Background

Before general computers, references to long lists of printed numbers [10] were used to manually pick random numbers. For early computers, the classic Handbook of Mathematical Functions (1965) [10] proposed programs for PRNG’s. An example is the linear congruential generator (LCG). The general form of a LCG is:

Xn+1=(aXn+c)modT.(1)
View Source

The LCG requires three parameters: {a, c, T}. A parametric inversion would assume an LCG and attempt identification of these three parameters whereas a nonparametric approach makes no assumptions about the model and attempts inversion by examining only a string of pseudo random numbers generated by the PRNG. Using a parametric prior, George Marsaglia presented a crack for a LCG [11]. The Python code is available [12]. Only a couple of dozens of consecutive pseudo random numbers are required to solve the inversion problem and identify the parameters.

Some LCGs, as it is the case of RANDU [2], are less effective because of a poor selection of the parameters in (1).

A more recent and effective PRNG is the Mersenne Twister [13]. But this PRNG is also invertible using a parametric model. Accordingly to Shema [12], the version MT19937 of the Mersenne Twister can be reverse engineered if a series of 624 consecutive numbers are known.

LCGs are Markov chains. A typical Mersenne Twister generates random numbers in batches of 624 integers each with 32 bit accuracy. Each batch derives from an internal state of the Mersenne Twister. The transition between states is also a Markov process in the sense that the previous state act as the seed for the next.

Savicky et al. [2] test some of the most commonly used PRNG’s by using neural networks to detect dependencies. Also see Fan et al. [14].

Taketa et al. [7] provide a theoretical analysis of the inverse relation between the mathematical complexity of the PRNG and the quality of the possible machine learning approximations. Li et al. [4] use deep learning to obtain approximate predictions of a PRNG with applications on randomness tests. They work with integers using a standard LCG and their method obtain accurate approximations when bounding the period of the LCG.

A more complex PRNG, introduced in the next section, is used for this work. It consists of a non-linear variation of the LCG that uses real numbers.

SECTION III.

## Methodology

To test whether a feed forward deep neural network (DNN) [15] can parametrically mimic a PRNG given a long string of data generated by the PRNG, we use a variation of the LCG in (1) suggested for use in early programmable calculators [16]. Specifically,

xn+1=frac[(xn+π)5](2)
View Source where “frac” is the fractional part operator and xn+1$x_{n+1}$ is the next output of the PRNG using xn as a seed. Then xn+1$x_{n+1}$ is used as the seed for xn+2$x_{n+2}$, etc. The PRNG is deterministic, but an initial random seed x0, chosen external to the procedure, makes the rest of the numbers in the sequence pseudo-stochastic. A plot of (xn+π)5$(x_{n}+\pi)^{5}$ for 0xn1$0\leq x_{n}\leq 1$ without the frac operation in (2) is in Figure 1.

The form of (2) was chosen in part because it kept key strokes to a minimum. Each of the operations of adding π$\pi$, exponent (to the fifth power) and frac requires a single key stroke.

Due to the range ceiling of the original PRNG (2), the output over the interval [0,1) wraps to 913 piece-wise continuous segments. The number of discontinuities is found according to

(π+1)5π5=912.5.
View Source

Figures 2, 3 and 4 show the zoom-in versions of the output of the original PRNG in (2). The geometrical visualization of application of the frac() part to Figure 1 consists of cutting the plot into pieces of height 1 and translating them down to the range [0,1).

Fig. 1.

A plot of (xn+π)5$(x_{n}+\pi)^{5}$ over the interval [0, 1].

Fig. 2.

Original PRNG in (2) over the interval [0, 0.005].

It is possible to approximate a piece-wise continuous function with a DNN [8], [9].

A simplified version of this PRNG is helpful for the experimentation process:

xn+1=frac[(xn+π3)5](3)
View Source

The experimentation with this simplified version of the PRNG provided some intermediate results and it also served as a starting point to solve the original version of the PRNG.

The PRNG in (2) is referred to as the original PRNG and the one in (3) the simplified PRNG.

Fig. 3.

Original PRNG in (2) over the interval [0.5, 0.505].

Fig. 4.

Original PRNG in (2) over the interval [0.995, 1).

The simplified PRNG reduces the number of continuous segments of the output over the range [0,1) from 913 to 35. Its shape is shown in Figure 5 over the entire range of [0,1).

SECTION IV.

## Experiments

The numbers of continuous segments of the original PRNG and the simplified PRNG differ by over an order of magnitude (from 913 to 35). Consequently the experiments for each of them use different DNN architectures and the preprocessing of the input also varies.

### A. Simplified PRNG

The complexity of the simplified PRNG already requires a DNN with many nodes and layers to learn the model. But the PRNG has only one input, xn, that proved insufficient to train the DNN. To solve this problem, a preprocessing step was added to the system consisting of a transformation from the one dimensional input to an 100-element vector:

[xn,2xn,,34xn,x2n,,x34n,x34n,,x2n](4)
View Source

This strategy with increased dimension of input does not suffer from the curse of dimensionality [17], because all the input features in (4) lie on a twisted one-dimensional line in a one-hundred-dimensional space.

Fig. 5.

Simplified PRNG in (3) over the interval [0,1).

Figure 6 shows the architecture of the DNN consisting of 10 layers with 100 nodes each except for the output layer that has 1 node. These are dense layers, the weight initialization is orthogonal [18] and the bias initialization is 0.1. The activation function for all the layers uses a sigmoid, optimizer ADAM, and the loss function is the mean squared error. The DNN is trained with 3 million pseudo random numbers using a batch size of 35,000 during 38 hours on a NVIDIA GPU model GTX 2080 Ti.

### B. Original PRNG

For the original PRNG, the one-dimensional input, xn, of the PRNG was preprocessed into a 512-element vector:

[xn, frac (xn+1512),, frac (xn+511512)](5)
View Source

The numbers of the vector in (4) sweep over a wide range. The vector in (5) restricts the range of the input on the unit interval while keeping the dimension of the input at 512. Note there is no raising the terms in (5) to the 5th power so no parametric hint is given to the DNN on the locations of the discontinuities in the PRNG. This choice of input worked well.

In the previous experiment, using the preprocessing of (4), it is observed that the training process starts by approximating all the predictions with a value around 0.5 and then slowly learns one segment piece at a time from left to right with high accuracy. The learning keeps going from left to right. The training process also presents diminishing returns. With the preprocessing of (5) the training is faster. Instead of learning slowly from left to right with diminishing returns, this preprocessing produces a faster learning pattern where all the pieces are learned simultaneously. The downside of the approach is a loss of accuracy.

Fig. 6.

Model of the DNN used to approximate the simplified PRNG.

Figure 7 shows the architecture of the DNN consisting of 3 layers of 512 nodes, 2 layers of 256 nodes and the output layer of 1 node. All the layers, except for the input layer, are interspersed with batch normalization. They are dense layers, he weight initialization is orthogonal and the bias initialization is 0.01. The activation function for all the layers is sigmoid, optimizer ADAM and the loss function is the mean squared error. It is trained with 1 million sequential pseudo random numbers using a batch size of 35,000 during 3 weeks on a NVIDIA GPU model Tesla V100.

Fig. 7.

Model of the DNN used to approximate the original PRNG.

SECTION V.

## Analysis

Following the previous section, the results of the simplified PRNG and the original PRNG are analyzed here.

### A. Simplified PRNG

The mean square error (average of the squared errors) value on the trained DNN versus target value is about 0.00236. The results are shown in Figures 8, 9, 10 and 11. Figure 8 shows the DNN approximations in orange superimposed over the true pseudo random numbers in blue. The accuracy is such that the blue color is only visible close to the discontinuities. Figure 9 illustrates the displacement between the DNN predictions and the pseudo random numbers. Again, the approximations are clear except for the points closer to the discontinuities of the PRNG function. Figures 10 and 11 show the same histogram with 250 bins from 100,000 samples, on different scales, illustrating the distribution of the error of the approximations of the DNN. For almost half of the cases the error (magnitude) is less than 0.004, and about 90% of the numbers are approximated with an error less than 0.02. The error histogram in Figure 10 is shown on a more informative log scale in Figure 11.

Fig. 8.

DNN predictions (orange) superposed to the simplified PRNG outputs (blue).

### B. Original PRNG

The mean square error of the trained DNN is 0.00261. The results are presented in Figures 12, 13 and 14. Figure 12 illustrates the displacement between the DNN predictions and the true pseudo random numbers. Figures 13 and 14 are the same histogram on different scales. They have 50 bins and were generated using 1,000,000 samples to illustrate the distribution of the error of the approximations of the DNN. For 60% of the cases the error is less than 0.04, and about 90% of the numbers are approximated with an error less than 0.1. The error histogram in Figure 13 is shown on log scale in Figure 14.

The primary sources of DNN error are seen graphically in Figure 9 where there are large variant spikes near 0 and 1. The same error is seen in Figure 12 where there are clouds shown in the upper left and lower right of the plot. Errors primarily arise from the sharp discontinuities in the PRNG. The discontinuities in (2) are evident in Figures 2 through 4. The training error for the simplified PRNG at the discontinuities is visible in Figure 8.

Fig. 9.

DNN predictions by PRNG outputs from 1,000,000 equidistributed numbers (simplified PRNG). The blue diagonal corresponds to zero error.

Fig. 10.

250 bins histogram of the error of the approximation for the simplified PRNG.

Here is an illustration of the source of these errors. A value of xn=0.2458111$x_{n}=0.2458111$ in the original PRNG gives (xn+π)5=$(x_{n}+\pi)^{5}=$ 445.9999625 and, therefore xn+1=0.9999625$x_{n+1}=0.9999625$. This is right on the edge of a discontinuity as illustrated by the very close xn=0.2458112$x_{n}=0.2458112$ giving (xn+π)5=446.0000283$(x_{n}+\pi)^{5}=446.0000283$ and a very different result of xn+1=0.0000283$x_{n+1}=0.0000283$. Very small errors close to 1 can thus give a result that flips the answer from a number close to 1 to a number close to 0. The converse is also true. This accounts for the spikes in Figure 9 and the two clouds in Figure 12. In Figure 12 the modulo extensions of the plot in the upper right hand corner can be seen both at the upper left and lower right of the figure. Although faint, there are vertical error streaks on both the left and right of Figure 12 akin to the spikes seen in Figure 9.

Fig. 11.

Same histogram as in Figure 10 on a logarithmic scale.

Fig. 12.

DNN predictions by PRNG outputs from 1,000,000 equidistributed numbers (original PRNG). The blue diagonal corresponds to 0 error.

SECTION VI.

## Conclusion

The modified linear congruential generator (LCG) can be mimicked by training a DNN. LCG’s are characterized by a piece-wise continuous function that can be learned by a DNN. Conventional DNN’s assume underlying continuity. The modified LCG in (2) consist of a non-linear piece-wise continuous function with many segments. We use DNN’s to approximate PRNG’s with tens and many hundreds of segments. It is a difficult task for DNN’s to learn functions with large amounts of jump discontinuities. Both theoretical and experimental work approximating non-linear functions with DNN’s is already available in the literature, as well as theoretical analysis on how DNN’s can approximate piecewise continuous functions. To our knowledge, this is the first article showing how a non-linear piece-wise continuous function with a multitude (913) of jump discontinuities can be approximated experimentally.

Fig. 13.

50 bins histogram of the error of the approximation (original PRNG).

Fig. 14.

Same histogram as in Figure 13 on a logarithmic scale.

The ability of DNN’s to nonparametrically crack LCG’s and parametrically invert the more sophisticated Mersenne Twister makes one worry about the use of PRNG’s in the fields of cryptography and gaming. Better quantum random number generators that cannot be inverted should be used. 4

2.
Quantum random number generators can be purchased at Amazon.com and are available on line. See. e.g., ANU QRNG: Quantum random numbers, https://qrng.anu.edu.au/random-hex/
3.
The Linux documentation of the dieharder package can be found on https://linux.die.net/man/l/dieharder .
4.
See, e.g. IDQ’s commercially available quantum devices for use in gaming and other areas. https://www.idquantique.com/

# References

1.R. Penrose and N. D. Mermin, “The emperor’s new mind: Concerning computers, minds, and the laws of physics,” American Journal of Physics, vol. 58, no. 12, pp. 1214–1216, 1990.
2.P. Savicky and M. Robnik-Šikonja, “Learning random numbers: A matlab anomaly,” Applied Artificial Intelligence, vol. 22, no. 3, pp. 254–265, 2008.
3.G. Marsaglia, “The marsaglia random number cdrom including the diehard battery of tests of randomness” http://www.stat.fsu.edu/pub/diehard, 2008.
4.C. Li, J. Zhang, L. Sang, L. Gong, L. Wang, A. Wang, and Y. Wang, “Deep learning-based security verification for a random number generator using white chaos,” Entropy, vol. 22, no. 10, 2020. [Online]. Available: https://www.mdpi.com/1099-4300/22110/1134
5.Divyanjali, Ankur, and V. Pareek, “Article: An overview of cryptographically secure pseudorandom number generators and bbs,” IJCA Proceedings on International Conference on Advances in Computer Engineering and Applications, vol. ICACEA, no. 2, pp. 19–28, March 2014.
6.Z. Gutterman, B. Pinkas, and T. Reinman, “Analysis of the linux random number generator,” in 2006 IEEE Symposium on Security and Privacy (SP’06), 2006, pp. 15 pp.–385.
7.Y. Taketa, Y. Kodera, S. Tanida, T. Kusaka, Y. Nogami, N. Takahashi, and S. Uehara, “Mutual relationship between the neural network model and linear complexity for pseudorandom binary number sequence,” in 2019 Seventh International Symposium on Computing and Networking Workshops (CANDARW), 2019, pp. 394–400.
8.M. Imaizumi and K. Fukumizu, “Deep neural networks learn non-smooth functions effectively,” in Proceedings of Machine Learning Research, ser. Proceedings of Machine Learning Research, K. Chaudhuri and M. Sugiyama, Eds., vol. 89. PMLR, 16–18 Apr 2019, pp. 869–878.
9.P. Petersen and F. Voigtländer, “Optimal approximation of piecewise smooth functions using deep relu neural networks,” Neural networks: the official journal of the International Neural Network Society, vol. 108, pp. 296–330, 2017.
10.M. Abramowitz and I. A. Stegun, Eds., Handbook of Mathematical Functions with Formulas, Graphs and Mathematical Tables. New York: Dover Publications, Inc., 1965.
11.G. Marsaglia, “Random number generators,” Journal of Modern Applied Statistical Methods, vol. 2, pp. 2–13, 2003.
12.M. Shema, Hacking Web Apps: Detecting and Preventing Web Application Security Problems. Elsevier Science, 2012.
13.M. Matsumoto and T. Nishimura, “Mersenne twister: a 623-dimensionally equidistributed uniform pseudo-random number generator,” ACM Transactions on Modeling and Computer Simulation (TOMACS), vol. 8, no. 1, pp. 3–30, 1998.
14.F. Fan and G. Wang, “Learning from pseudo-randomness with an artificial neural network-does god play pseudo-dice?” IEEE Access, vol. 6, pp. 22987–22992, 2018.
15.R. Reed and R. J. Marks II, Neural smithing: supervised learning in feedforward artificial neural networks. Mit Press, 1999.
16.HP-Museum, “The museum of hp calculators,” https://www.hpmuseum.org/, Accessed January 30, 2021.
17.R. E. Bellman, Adaptative Control Processes. Princeton University Press, 2015.
18.A. M. Saxe, J. L. McClelland, and S. Ganguli, “Exact solutions to the nonlinear dynamics of learning in deep linear neural networks,” in 2nd International Conference on Learning Representations, ICLR 2014, Banff, AB, Canada, April 14–16, 2014, Conference Track Proceedings, Y. Bengio and Y. LeCun, Eds., 2014.


text:
If the standard deviation of 0,1,2, 3............9 in K, the standard deviation of 10,11,12,13......19 is

Using

Standard Deviation -

In case of discrete frequency distribution

$\dpi{100} \sigma = \sqrt{\frac{\sum f_{i}x_{i}^{2}}{\sum f_{i}}-\left ( \frac{\sum f_{i}x_{i}}{\sum f_{i}} \right )^{2}}$

-

Since, $\sigma ^{2} = \frac{\sum \left ( x_{i} - \bar{x}\right )^{2}}{n}$

and each data increases by $\lambda \left ( \lambda =10 \right )$ then there will be no change in standard deviation because $\left ( x_{i}-\bar{x} \right )$ will be same.

So, new standard deviation is K.

Preparation Products

Knockout JEE Main Sept 2020

An exhaustive E-learning program for the complete preparation of JEE Main..

₹ 12999/- ₹ 6999/-
Rank Booster JEE Main 2020

This course will help student to be better prepared and study in the right direction for JEE Main..

₹ 9999/- ₹ 4999/-
Test Series JEE Main Sept 2020

Take chapter-wise, subject-wise and Complete syllabus mock tests and get in depth analysis of your test..

₹ 4999/- ₹ 1999/-
Knockout JEE Main April 2021

An exhaustive E-learning program for the complete preparation of JEE Main..

₹ 22999/- ₹ 14999/-