使用numpy库完成Polynomial相关代码。

## Requirement

One way of looking at the dimensionality of an object is to examine how the “amount inside” scales with the linear dimension of the object. For example, we know the area of a circle is given by `A = πr^2`

. As shown in Fig. 1, one could count the squares inside a set of circles and plot the number vs r. Then by fitting a function `A(r) = ar^d`

to the data points you could determine an approximate formula for the area, and the exponent d gives the dimensionality of the circle. It should come out very close to 2, but of course there will be some error from counting or not counting squares that don’t quite fit the circle.

In homework 9 you did a polynomial fit using `numpy.polyfit()`

but here you need to determine the power and therefore can’t fit a polynomial which has fixed integer powers.

Instead you can use `scipy.optimize.curve_fit()`

, which is documented online. There are of course other possible methods, which you are free to try.

Now consider the diffusion limited aggregation (DLA) simulations we have worked with. We can apply the same area law method outlined above to a DLA cluster, counting the number of stuck particles inside a given radius. You can see from Fig. 2 that the voids in the cluster mean the number of particles will grow more slowly than the number of grid sites shown in Fig. 2. Fitting a function `N(r) = ar^d`

to the number of particles vs r, the number d is called the fractal dimension of the cluster. Since the cluster has a finite size, one needs to be careful to use circles that are small enough that they don’t simply include a lot of empty space beyond the cluster dimensions.

Your assignment is to write a program to compute the fractal dimension of DLA clusters in 2 dimensions. There is an updated DLA python program on icon that has been sped up with numba and has some improvements in how the new particles are started off: they start off closer to the cluster and are distributed uniformly around the center. With these improvements, you shouldn’t have to wait too long to generate a nice big cluster.

Rather than writing a single program, you will probably want to write multiple programs that save results in files that are read by subsequent programs. The basic procedure is

- (1) Generate a cluster and count the number of particles within different radii.
- (2) You will need to play with the cluster size and also chose a maximum radius that isn’t too big.
- (3) Use scipy.optimize.curve fit() (or something else) to fit a function N (r) = ard to your data.
- (4) Repeat the above. Each time you will get a slightly different value of the fractal dimension d. Accumulate these measurements using the Datum class to determine the mean and standard deviation of d.
- (5) As a bonus, you can see how the size of the clusters affects the error in the final result.

Articles with more information on diffusion limited aggregation and fractal dimensions can be found on wikipedia.