text
stringlengths
87
777k
meta.hexsha
stringlengths
40
40
meta.size
int64
682
1.05M
meta.ext
stringclasses
1 value
meta.lang
stringclasses
1 value
meta.max_stars_repo_path
stringlengths
8
226
meta.max_stars_repo_name
stringlengths
8
109
meta.max_stars_repo_head_hexsha
stringlengths
40
40
meta.max_stars_repo_licenses
sequencelengths
1
5
meta.max_stars_count
int64
1
23.9k
meta.max_stars_repo_stars_event_min_datetime
stringlengths
24
24
meta.max_stars_repo_stars_event_max_datetime
stringlengths
24
24
meta.max_issues_repo_path
stringlengths
8
226
meta.max_issues_repo_name
stringlengths
8
109
meta.max_issues_repo_head_hexsha
stringlengths
40
40
meta.max_issues_repo_licenses
sequencelengths
1
5
meta.max_issues_count
int64
1
15.1k
meta.max_issues_repo_issues_event_min_datetime
stringlengths
24
24
meta.max_issues_repo_issues_event_max_datetime
stringlengths
24
24
meta.max_forks_repo_path
stringlengths
8
226
meta.max_forks_repo_name
stringlengths
8
109
meta.max_forks_repo_head_hexsha
stringlengths
40
40
meta.max_forks_repo_licenses
sequencelengths
1
5
meta.max_forks_count
int64
1
6.05k
meta.max_forks_repo_forks_event_min_datetime
stringlengths
24
24
meta.max_forks_repo_forks_event_max_datetime
stringlengths
24
24
meta.avg_line_length
float64
15.5
967k
meta.max_line_length
int64
42
993k
meta.alphanum_fraction
float64
0.08
0.97
meta.converted
bool
1 class
meta.num_tokens
int64
33
431k
meta.lm_name
stringclasses
1 value
meta.lm_label
stringclasses
3 values
meta.lm_q1_score
float64
0.56
0.98
meta.lm_q2_score
float64
0.55
0.97
meta.lm_q1q2_score
float64
0.5
0.93
text_lang
stringclasses
53 values
text_lang_conf
float64
0.03
1
label
float64
0
1
# Introduction to zfit In this notebook, we will have a walk through the main components of zfit and their features. Especially the extensive model building part will be discussed separately. zfit consists of 5 mostly independent parts. Other libraries can rely on this parts to do plotting or statistical inference, such as hepstats does. Therefore we will discuss two libraries in this tutorial: zfit to build models, data and a loss, minimize it and get a fit result and hepstats, to use the loss we built here and do inference. ## Data This component in general plays a minor role in zfit: it is mostly to provide a unified interface for data. Preprocessing is therefore not part of zfit and should be done beforehand. Python offers many great possibilities to do so (e.g. Pandas). zfit `Data` can load data from various sources, most notably from Numpy, Pandas DataFrame, TensorFlow Tensor and ROOT (using uproot). It is also possible, for convenience, to convert it directly `to_pandas`. The constructors are named `from_numpy`, `from_root` etc. ```python import zfit from zfit import z import tensorflow as tf import numpy as np import matplotlib.pyplot as plt ``` A `Data` needs not only the data itself but also the observables: the human readable string identifiers of the axes (corresponding to "columns" of a Pandas DataFrame). It is convenient to define the `Space` not only with the observable but also with a limit: this can directly be re-used as the normalization range in the PDF. First, let's define our observables ```python obs = zfit.Space('obs1', (-5, 10)) ``` This `Space` has limits. Next to the effect of handling the observables, we can also play with the limits: multiple `Spaces` can be added to provide disconnected ranges. More importantly, `Space` offers functionality: - limit1d: return the lower and upper limit in the 1 dimensional case (raises an error otherwise) - rect_limits: return the n dimensional limits - area(): calculate the area (e.g. distance between upper and lower) - inside(): return a boolean Tensor corresponding to whether the value is _inside_ the `Space` - filter(): filter the input values to only return the one inside ```python size_normal = 10000 data_normal_np = np.random.normal(size=size_normal, scale=2) data_normal = zfit.Data.from_numpy(obs=obs, array=data_normal_np) ``` The main functionality is - nevents: attribute that returns the number of events in the object - data_range: a `Space` that defines the limits of the data; if outside, the data will be cut - n_obs: defines the number of dimensions in the dataset - with_obs: returns a subset of the dataset with only the given obs - weights: event based weights Furthermore, `value` returns a Tensor with shape `(nevents, n_obs)`. To retrieve values, in general `z.unstack_x(data)` should be used; this returns a single Tensor with shape (nevents) or a list of tensors if `n_obs` is larger then 1. ```python print(f"We have {data_normal.nevents} events in our dataset with the minimum of {np.min(data_normal.unstack_x())}") # remember! The obs cut out some of the data ``` We have 9950 events in our dataset with the minimum of -4.979805501079585 ```python data_normal.n_obs ``` 1 ## Model Building models is by far the largest part of zfit. We will therefore cover an essential part, the possibility to build custom models, in an extra chapter. Let's start out with the idea that you define your parameters and your observable space; the latter is the expected input data. There are two types of models in zfit: - functions, which are rather simple and "underdeveloped"; their usage is often not required. - PDF that are function which are normalized (over a specified range); this is the main model and is what we gonna use throughout the tutorials. A PDF is defined by \begin{align} \mathrm{PDF}_{f(x)}(x; \theta) = \frac{f(x; \theta)}{\int_{a}^{b} f(x; \theta)} \end{align} where a and b define the normalization range (`norm_range`), over which (by inserting into the above definition) the integral of the PDF is unity. zfit has a modular approach to things and this is also true for models. While the normalization itself (e.g. what are parameters, what is normalized data) will already be pre-defined in the model, models are composed of functions that are transparently called inside. For example, a Gaussian would usually be implemented by writing a Python function `def gauss(x, mu, sigma)`, which does not care about the normalization and then be wrapped in a PDF, where the normalization and what is a parameter is defined. In principle, we can go far by using simply functions (e.g. [TensorFlowAnalysis/AmpliTF](https://github.com/apoluekt/AmpliTF) by Anton Poluektov uses this approach quite successfully for Amplitude Analysis), but this design has limitations for a more general fitting library such as zfit (or even [TensorWaves](https://github.com/ComPWA/tensorwaves), being built on top of AmpliTF). The main thing is to keep track of the different ordering of the data and parameters, especially the dependencies. Let's create a simple Gaussian PDF. We already defined the `Space` for the data before, now we only need the parameters. This are a different object than a `Space`. ### Parameter A `Parameter` (there are different kinds actually, more on that later) takes the following arguments as input: `Parameter(human readable name, initial value[, lower limit, upper limit])` where the limits are recommended but not mandatory. Furthermore, `step_size` can be given (which is useful to be around the given uncertainty, e.g. for large yields or small values it can help a lot to set this). Also, a `floating` argument is supported, indicating whether the parameter is allowed to float in the fit or not (just omitting the limits does _not_ make a parameter constant). Parameters have a unique name. This is served as the identifier for e.g. fit results. However, a parameter _cannot_ be retrieved by its string identifier (its name) but the object itself should be used. In places where a parameter maps to something, the object itself is needed, not its name. ```python mu = zfit.Parameter('mu', 1, -3, 3, step_size=0.2) sigma_num = zfit.Parameter('sigma42', 1, 0.1, 10, floating=False) ``` These attributes can be changed: ```python print(f"sigma is float: {sigma_num.floating}") sigma_num.floating = True print(f"sigma is float: {sigma_num.floating}") ``` sigma is float: False sigma is float: True *PITFALL NOTEBOOKS: since the parameters have a unique name, a second parameter with the same name cannot be created; the behavior is undefined and therefore it raises an error. While this does not pose a problem in a normal Python script, it does in a Jupyter-like notebook, since it is an often practice to "rerun" a cell as an attempt to "reset" things. Bear in mind that this does not make sense, from a logic point of view. The parameter already exists. Best practice: write a small wrapper, do not rerun the parameter creation cell or simply rerun the notebook (restart kernel & run all). For further details, have a look at the discussion and arguments [here](https://github.com/zfit/zfit/issues/186)* Now we have everything to create a Gaussian PDF: ```python gauss = zfit.pdf.Gauss(obs=obs, mu=mu, sigma=sigma_num) ``` Since this holds all the parameters and the observables are well defined, we can retrieve them ```python gauss.n_obs # dimensions ``` 1 ```python gauss.obs ``` ('obs1',) ```python gauss.space ``` <zfit Space obs=('obs1',), axes=(0,), limits=(array([[-5.]]), array([[10.]]))> ```python gauss.norm_range ``` <zfit Space obs=('obs1',), axes=(0,), limits=(array([[-5.]]), array([[10.]]))> As we've seen, the `obs` we defined is the `space` of Gauss: this acts as the default limits whenever needed (e.g. for sampling). `gauss` also has a `norm_range`, which equals by default as well to the `obs` given, however, we can explicitly change that with `set_norm_range`. We can also access the parameters of the PDF in two ways, depending on our intention: either by _name_ (the parameterization name, e.g. `mu` and `sigma`, as defined in the `Gauss`), which is useful if we are interested in the parameter that _describes_ the shape ```python gauss.params ``` OrderedDict([('mu', <zfit.Parameter 'mu' floating=True value=1>), ('sigma', <zfit.Parameter 'sigma42' floating=True value=1>)]) or to retrieve all the parameters that the PDF depends on. As this now may sounds trivial, we will see later that models can depend on other models (e.g. sums) and parameters on other parameters. There is one function that automatically retrieves _all_ dependencies, `get_params`. It takes three arguments to filter: - floating: whether to filter only floating parameters, only non-floating or don't discriminate - is_yield: if it is a yield, or not a yield, or both - extract_independent: whether to recursively collect all parameters. This, and the explanation for why independent, can be found later on in the `Simultaneous` tutorial. Usually, the default is exactly what we want if we look for _all free parameters that this PDF depends on_. ```python gauss.get_params() ``` OrderedSet([<zfit.Parameter 'mu' floating=True value=1>, <zfit.Parameter 'sigma42' floating=True value=1>]) The difference will also be clear if we e.g. use the same parameter twice: ```python gauss_only_mu = zfit.pdf.Gauss(obs=obs, mu=mu, sigma=mu) print(f"params={gauss_only_mu.params}") print(f"get_params={gauss_only_mu.get_params()}") ``` params=OrderedDict([('mu', <zfit.Parameter 'mu' floating=True value=1>), ('sigma', <zfit.Parameter 'mu' floating=True value=1>)]) get_params=OrderedSet([<zfit.Parameter 'mu' floating=True value=1>]) ## Functionality PDFs provide a few useful methods. The main features of a zfit PDF are: - `pdf`: the normalized value of the PDF. It takes an argument `norm_range` that can be set to `False`, in which case we retrieve the unnormalized value - `integrate`: given a certain range, the PDF is integrated. As `pdf`, it takes a `norm_range` argument that integrates over the unnormalized `pdf` if set to `False` - `sample`: samples from the pdf and returns a `Data` object ```python integral = gauss.integrate(limits=(-1, 3)) # corresponds to 2 sigma integral integral ``` <tf.Tensor: shape=(1,), dtype=float64, numpy=array([0.95449974])> ### Tensors As we see, many zfit functions return Tensors. This is however no magical thing! If we're outside of models, than we can always safely convert them to a numpy array by calling `zfit.run(...)` on it (or any structure containing potentially multiple Tensors). However, this may not even be required often! They can be added just like numpy arrays and interact well with Python and Numpy: ```python np.sqrt(integral) ``` array([0.97698502]) They also have shapes, dtypes, can be slices etc. So do not convert them except you need it. More on this can be seen in the talk later on about zfit and TensorFlow 2.0. ```python sample = gauss.sample(n=1000) # default space taken as limits sample ``` <zfit.core.data.SampleData at 0x7f1790089d00> ```python sample.unstack_x()[:10] ``` <tf.Tensor: shape=(10,), dtype=float64, numpy= array([-0.09952247, 1.49016828, 2.12148953, 0.39491123, 1.08061772, 0.49297195, 0.57305784, 1.98737622, 1.46084697, 0.30197322])> ```python sample.n_obs ``` 1 ```python sample.obs ``` ('obs1',) We see that sample returns also a zfit `Data` object with the same space as it was sampled in. This can directly be used e.g. ```python probs = gauss.pdf(sample) probs[:10] ``` <tf.Tensor: shape=(10,), dtype=float64, numpy= array([0.21796662, 0.35378319, 0.21271375, 0.33220443, 0.39764798, 0.35082167, 0.36419045, 0.24502515, 0.35875036, 0.31268492])> **NOTE**: In case you want to do this repeatedly (e.g. for toy studies), there is a way more efficient way (see later on) ## Plotting so far, we have a dataset and a PDF. Before we go for fitting, we can make a plot. This functionality is not _directly_ provided in zfit (but can be added to [zfit-physics](https://github.com/zfit/zfit-physics)). It is however simple enough to do it: ```python def plot_model(model, data, scale=1, plot_data=True): # we will use scale later on nbins = 50 lower, upper = data.data_range.limit1d x = tf.linspace(lower, upper, num=1000) # np.linspace also works y = model.pdf(x) * size_normal / nbins * data.data_range.area() y *= scale plt.plot(x, y) data_plot = zfit.run(z.unstack_x(data)) # we could also use the `to_pandas` method if plot_data: plt.hist(data_plot, bins=nbins) ``` ```python plot_model(gauss, data_normal) ``` We can of course do better (and will see that later on, continuously improve the plots), but this is quite simple and gives us the full power of matplotlib. ### Different models zfit offers a selection of predefined models (and extends with models from zfit-physics that contain physics specific models such as ARGUS shaped models). ```python print(zfit.pdf.__all__) ``` ['BasePDF', 'BaseFunctor', 'Exponential', 'CrystalBall', 'DoubleCB', 'Gauss', 'Uniform', 'TruncatedGauss', 'WrapDistribution', 'Cauchy', 'Chebyshev', 'Legendre', 'Chebyshev2', 'Hermite', 'Laguerre', 'RecursivePolynomial', 'ProductPDF', 'SumPDF', 'GaussianKDE1DimV1', 'ZPDF', 'SimplePDF', 'SimpleFunctorPDF'] To create a more realistic model, we can build some components for a mass fit with a - signal component: CrystalBall - combinatorial background: Exponential - partial reconstructed background on the left: Kernel Density Estimation ```python mass_obs = zfit.Space('mass', (0, 1000)) ``` ```python # Signal component mu_sig = zfit.Parameter('mu_sig', 400, 100, 600) sigma_sig = zfit.Parameter('sigma_sig', 50, 1, 100) alpha_sig = zfit.Parameter('alpha_sig', 300, 100, 400) n_sig = zfit.Parameter('n sig', 4, 0.1, 30) signal = zfit.pdf.CrystalBall(obs=mass_obs, mu=mu_sig, sigma=sigma_sig, alpha=alpha_sig, n=n_sig) ``` ```python # combinatorial background lam = zfit.Parameter('lambda', -0.01, -0.05, -0.001) comb_bkg = zfit.pdf.Exponential(lam, obs=mass_obs) ``` ```python part_reco_data = np.random.normal(loc=200, scale=150, size=700) part_reco_data = zfit.Data.from_numpy(obs=mass_obs, array=part_reco_data) # we don't need to do this but now we're sure it's inside the limits part_reco = zfit.pdf.GaussianKDE1DimV1(obs=mass_obs, data=part_reco_data, bandwidth='adaptive') ``` ## Composing models We can also compose multiple models together. Here we'll stick to one dimensional models, the extension to multiple dimensions is explained in the "custom models tutorial". Here we will use a `SumPDF`. This takes pdfs and fractions. If we provide n pdfs and: - n - 1 fracs: the nth fraction will be 1 - sum(fracs) - n fracs: no normalization attempt is done by `SumPDf`. If the fracs are not implicitly normalized, this can lead to bad fitting behavior if there is a degree of freedom too much ```python sig_frac = zfit.Parameter('sig_frac', 0.3, 0, 1) comb_bkg_frac = zfit.Parameter('comb_bkg_frac', 0.25, 0, 1) model = zfit.pdf.SumPDF([signal, comb_bkg, part_reco], [sig_frac, comb_bkg_frac]) ``` In order to have a corresponding data sample, we can just create one. Since we want to fit to this dataset later on, we will create it with slightly different values. Therefore, we can use the ability of a parameter to be set temporarily to a certain value with ```python print(f"before: {sig_frac}") with sig_frac.set_value(0.25): print(f"new value: {sig_frac}") print(f"after 'with': {sig_frac}") ``` before: <zfit.Parameter 'sig_frac' floating=True value=0.3> new value: <zfit.Parameter 'sig_frac' floating=True value=0.25> after 'with': <zfit.Parameter 'sig_frac' floating=True value=0.3> While this is useful, it does not fully scale up. We can use the `zfit.param.set_values` helper therefore. (_Sidenote: instead of a list of values, we can also use a `FitResult`, the given parameters then take the value from the result_) ```python with zfit.param.set_values([mu_sig, sigma_sig, sig_frac, comb_bkg_frac, lam], [370, 34, 0.18, 0.15, -0.006]): data = model.sample(n=10000) ``` ```python plot_model(model, data); ``` Plotting the components is not difficult now: we can either just plot the pdfs separately (as we still can access them) or in a generalized manner by accessing the `pdfs` attribute: ```python def plot_comp_model(model, data): for mod, frac in zip(model.pdfs, model.params.values()): plot_model(mod, data, scale=frac, plot_data=False) plot_model(model, data) ``` ```python plot_comp_model(model, data) ``` Now we can add legends etc. Btw, did you notice that actually, the `frac` params are zfit `Parameters`? But we just used them as if they were Python scalars and it works. ```python print(model.params) ``` OrderedDict([('frac_0', <zfit.Parameter 'sig_frac' floating=True value=0.3>), ('frac_1', <zfit.Parameter 'comb_bkg_frac' floating=True value=0.25>), ('frac_2', <zfit.ComposedParameter 'Composed_autoparam_2' params=OrderedDict([('param_0', <zfit.Parameter 'sig_frac' floating=True value=0.3>), ('param_1', <zfit.Parameter 'comb_bkg_frac' floating=True value=0.25>)]) value=0.45>)]) ### Extended PDFs So far, we have only looked at normalized PDFs that do contain information about the shape but not about the _absolute_ scale. We can make a PDF extended by adding a yield to it. The behavior of the new, extended PDF does **NOT change**, any methods we called before will act the same. Only exception, some may require an argument _less_ now. All the methods we used so far will return the same values. What changes is that the flag `model.is_extended` now returns `True`. Furthermore, we have now a few more methods that we can use which would have raised an error before: - `get_yield`: return the yield parameter (notice that the yield is _not_ added to the shape parameters `params`) - `ext_{pdf,integrate}`: these methods return the same as the versions used before, however, multiplied by the yield - `sample` is still the same, but does not _require_ the argument `n` anymore. By default, this will now equal to a _poissonian sampled_ n around the yield. The `SumPDF` now does not strictly need `fracs` anymore: if _all_ input PDFs are extended, the sum will be as well and use the (normalized) yields as fracs The preferred way to create an extended PDf is to use `PDF.create_extended(yield)`. However, since this relies on copying the PDF (which may does not work for different reasons), there is also a `set_yield(yield)` method that sets the yield in-place. This won't lead to ambiguities, as everything is supposed to work the same. ```python yield_model = zfit.Parameter('yield_model', 10000, 0, 20000, step_size=10) model_ext = model.create_extended(yield_model) ``` alternatively, we can create the models as extended and sum them up ```python sig_yield = zfit.Parameter('sig_yield', 2000, 0, 10000, step_size=1) sig_ext = signal.create_extended(sig_yield) comb_bkg_yield = zfit.Parameter('comb_bkg_yield', 6000, 0, 10000, step_size=1) comb_bkg_ext = comb_bkg.create_extended(comb_bkg_yield) part_reco_yield = zfit.Parameter('part_reco_yield', 2000, 0, 10000, step_size=1) part_reco.set_yield(part_reco_yield) # unfortunately, `create_extended` does not work here. But no problem, it won't change anyting. part_reco_ext = part_reco ``` ```python model_ext_sum = zfit.pdf.SumPDF([sig_ext, comb_bkg_ext, part_reco_ext]) ``` # Loss A loss combines the model and the data, for example to build a likelihood. Furthermore, it can contain constraints, additions to the likelihood. Currently, if the `Data` has weights, these are automatically taken into account. ```python nll_gauss = zfit.loss.UnbinnedNLL(gauss, data_normal) ``` The loss has several attributes to be transparent to higher level libraries. We can calculate the value of it using `value`. ```python nll_gauss.value() ``` <tf.Tensor: shape=(), dtype=float64, numpy=32625.929833399066> Notice that due to graph building, this will take significantly longer on the first run. Rerun the cell above and it will be way faster. Furthermore, the loss also provides a possibility to calculate the gradients or, often used, the value and the gradients. We can access the data and models (and possible constraints) ```python nll_gauss.model ``` [<zfit.Gauss params=[mu, sigma42] dtype=float64>0] ```python nll_gauss.data ``` [<zfit.core.data.Data at 0x7f17900ed820>] ```python nll_gauss.constraints ``` [] Similar to the models, we can also get the parameters via `get_params`. ```python nll_gauss.get_params() ``` OrderedSet([<zfit.Parameter 'mu' floating=True value=1>, <zfit.Parameter 'sigma42' floating=True value=1>]) ### Extended loss More interestingly, we can now build a loss for our composite sum model using the sampled data. Since we created an extended model, we can now also create an extended likelihood, taking into account a Poisson term to match the yield to the number of events. ```python nll = zfit.loss.ExtendedUnbinnedNLL(model_ext_sum, data) ``` ```python nll.get_params() ``` OrderedSet([<zfit.Parameter 'sig_yield' floating=True value=2000>, <zfit.Parameter 'comb_bkg_yield' floating=True value=6000>, <zfit.Parameter 'part_reco_yield' floating=True value=2000>, <zfit.Parameter 'alpha_sig' floating=True value=300>, <zfit.Parameter 'mu_sig' floating=True value=400>, <zfit.Parameter 'n sig' floating=True value=4>, <zfit.Parameter 'sigma_sig' floating=True value=50>, <zfit.Parameter 'lambda' floating=True value=-0.01>]) # Minimization While a loss is interesting, we usually want to minimize it. Therefore we can use the minimizers in zfit, most notably `Minuit`, a wrapper around the [iminuit minimizer](https://github.com/scikit-hep/iminuit). The philosophy is to create a minimizer instance that is mostly _stateless_, e.g. does not remember the position (there are considerations to make it possible to have a state, in case you feel interested, [contact us](https://github.com/zfit/zfit#contact)) Given that iminuit provides us with a very reliable and stable minimizer, it is usually recommended to use this. Others are implemented as well and could easily be wrapped, however, the convergence is usually not as stable. Minuit has a few options: - `tolerance`: the Estimated Distance to Minimum (EDM) criteria for convergence (default 1e-3) - `verbosity`: between 0 and 10, 5 is normal, 7 is verbose, 10 is maximum - `use_minuit_grad`: if True, uses the Minuit numerical gradient instead of the TensorFlow gradient. This is usually more stable for smaller fits; furthermore the TensorFlow gradient _can_ (experience based) sometimes be wrong. ```python minimizer = zfit.minimize.Minuit(use_minuit_grad=True) ``` For the minimization, we can call `minimize`, which takes a - loss as we created above - optionally: the parameters to minimize By default, `minimize` uses all the free floating parameters (obtained with `get_params`). We can also explicitly specify which ones to use by giving them (or better, objects that depend on them) to `minimize`; note however that non-floating parameters, even if given explicitly to `minimize` won 't be minimized. ## Pre-fit parts of the PDF Before we want to fit the whole PDF however, it can be useful to pre-fit it. A way can be to fix the combinatorial background by fitting the exponential to the right tail. Therefore we create a new data object with an additional cut and furthermore, set the normalization range of the background pdf to the range we are interested in. ```python values = z.unstack_x(data) obs_right_tail = zfit.Space('mass', (700, 1000)) data_tail = zfit.Data.from_tensor(obs=obs_right_tail, tensor=values) with comb_bkg.set_norm_range(obs_right_tail): nll_tail = zfit.loss.UnbinnedNLL(comb_bkg, data_tail) minimizer.minimize(nll_tail) ``` ------------------------------------------------------------------ | FCN = 328 | Ncalls=19 (19 total) | | EDM = 9.18e-10 (Goal: 0.001) | up = 0.5 | ------------------------------------------------------------------ | Valid Min. | Valid Param. | Above EDM | Reached call limit | ------------------------------------------------------------------ | True | True | False | False | ------------------------------------------------------------------ | Hesse failed | Has cov. | Accurate | Pos. def. | Forced | ------------------------------------------------------------------ | False | True | True | True | False | ------------------------------------------------------------------ Since we now fit the lambda parameter of the exponential, we can fix it. ```python lam.floating = False lam ``` <zfit.Parameter 'lambda' floating=False value=-0.008587> ```python result = minimizer.minimize(nll) ``` ------------------------------------------------------------------ | FCN = -1.93e+04 | Ncalls=185 (185 total) | | EDM = 6.35e-06 (Goal: 0.001) | up = 0.5 | ------------------------------------------------------------------ | Valid Min. | Valid Param. | Above EDM | Reached call limit | ------------------------------------------------------------------ | True | True | False | False | ------------------------------------------------------------------ | Hesse failed | Has cov. | Accurate | Pos. def. | Forced | ------------------------------------------------------------------ | False | True | True | True | False | ------------------------------------------------------------------ ```python plot_comp_model(model_ext_sum, data) ``` # Fit result The result of every minimization is stored in a `FitResult`. This is the last stage of the zfit workflow and serves as the interface to other libraries. Its main purpose is to store the values of the fit, to reference to the objects that have been used and to perform (simple) uncertainty estimation. ```python print(result) ``` FitResult of <ExtendedUnbinnedNLL model=[<zfit.SumPDF params=[Composed_autoparam_5, Composed_autoparam_6, Composed_autoparam_7] dtype=float64>0] data=[<zfit.core.data.SampleData object at 0x7f176002fdc0>] constraints=[]> with <Minuit strategy=PushbackStrategy tolerance=0.001> ╒═════════╤═════════════╤══════════════════╤═════════╤═════════════╕ │ valid │ converged │ param at limit │ edm │ min value │ ╞═════════╪═════════════╪══════════════════╪═════════╪═════════════╡ │ True │ True │ False │ 6.4e-06 │ -1.93e+04 │ ╘═════════╧═════════════╧══════════════════╧═════════╧═════════════╛ Parameters name value at limit --------------- ------- ---------- sig_yield 1804 False comb_bkg_yield 1095 False part_reco_yield 7101 False alpha_sig 300 False mu_sig 370.8 False n sig 4 False sigma_sig 33.87 False This gives an overview over the whole result. Often we're mostly interested in the parameters and their values, which we can access with a `params` attribute. ```python print(result.params) ``` name value at limit --------------- ------- ---------- sig_yield 1804 False comb_bkg_yield 1095 False part_reco_yield 7101 False alpha_sig 300 False mu_sig 370.8 False n sig 4 False sigma_sig 33.87 False This is a `dict` which stores any knowledge about the parameters and can be accessed by the parameter (object) itself: ```python result.params[mu_sig] ``` {'value': 370.7878667059073} 'value' is the value at the minimum. To obtain other information about the minimization process, `result` contains more attributes: - fmin: the function minimum - edm: estimated distance to minimum - info: contains a lot of information, especially the original information returned by a specific minimizer - converged: if the fit converged ```python result.fmin ``` -19300.779346305906 ## Estimating uncertainties The `FitResult` has mainly two methods to estimate the uncertainty: - a profile likelihood method (like MINOS) - Hessian approximation of the likelihood (like HESSE) When using `Minuit`, this uses (currently) it's own implementation. However, zfit has its own implementation, which are likely to become the standard and can be invoked by changing the method name. Hesse is also [on the way to implement](https://github.com/zfit/zfit/pull/244) the [corrections for weights](https://inspirehep.net/literature/1762842). We can explicitly specify which parameters to calculate, by default it does for all. ```python result.hesse() ``` OrderedDict([(<zfit.Parameter 'sig_yield' floating=True value=1804>, {'error': 70.15087267737408}), (<zfit.Parameter 'comb_bkg_yield' floating=True value=1095>, {'error': 70.35114369167526}), (<zfit.Parameter 'part_reco_yield' floating=True value=7101>, {'error': 131.80924912505543}), (<zfit.Parameter 'alpha_sig' floating=True value=300>, {'error': 141.4213562373095}), (<zfit.Parameter 'mu_sig' floating=True value=370.8>, {'error': 1.3661545484142485}), (<zfit.Parameter 'n sig' floating=True value=4>, {'error': 10.069756698215553}), (<zfit.Parameter 'sigma_sig' floating=True value=33.87>, {'error': 1.2650183734125646})]) ```python # result.hesse(method='hesse_np') ``` We get the result directly returned. This is also added to `result.params` for each parameter and is nicely displayed with an added column ```python print(result.params) ``` name value minuit_hesse at limit --------------- ------- -------------- ---------- sig_yield 1804 +/- 70 False comb_bkg_yield 1095 +/- 70 False part_reco_yield 7101 +/- 1.3e+02 False alpha_sig 300 +/- 1.4e+02 False mu_sig 370.8 +/- 1.4 False n sig 4 +/- 10 False sigma_sig 33.87 +/- 1.3 False ```python errors, new_result = result.errors(params=[sig_yield, part_reco_yield, mu_sig]) # just using three for speed reasons ``` /home/jonas/Documents/physics/software/zfit_project/zfit_repo/zfit/minimizers/fitresult.py:360: FutureWarning: 'minuit_minos' will be changed as the default errors method to a custom implementationwith the same functionality. If you want to make sure that 'minuit_minos' will be used in the future, add it explicitly as in `errors(method='minuit_minos')` warnings.warn("'minuit_minos' will be changed as the default errors method to a custom implementation" ```python # errors, new_result = result.errors(params=[yield_model, sig_frac, mu_sig], method='zfit_error') ``` ```python print(errors) ``` OrderedDict([(<zfit.Parameter 'sig_yield' floating=True value=1804>, MError(name='sig_yield', is_valid=True, lower=-69.66325485797651, upper=70.75759128186598, lower_valid=True, upper_valid=True, at_lower_limit=False, at_upper_limit=False, at_lower_max_fcn=False, at_upper_max_fcn=False, lower_new_min=False, upper_new_min=False, nfcn=138, min=1803.8532804234746)), (<zfit.Parameter 'part_reco_yield' floating=True value=7101>, MError(name='part_reco_yield', is_valid=True, lower=-131.88637854089905, upper=132.34447403753458, lower_valid=True, upper_valid=True, at_lower_limit=False, at_upper_limit=False, at_lower_max_fcn=False, at_upper_max_fcn=False, lower_new_min=False, upper_new_min=False, nfcn=60, min=7101.093509366213)), (<zfit.Parameter 'mu_sig' floating=True value=370.8>, MError(name='mu_sig', is_valid=True, lower=-1.36717243612375, upper=1.356060293846917, lower_valid=True, upper_valid=True, at_lower_limit=False, at_upper_limit=False, at_lower_max_fcn=False, at_upper_max_fcn=False, lower_new_min=False, upper_new_min=False, nfcn=106, min=370.7878667059073))]) ```python print(result.params) ``` name value minuit_hesse minuit_minos at limit --------------- ------- -------------- ------------------- ---------- sig_yield 1804 +/- 70 - 70 + 71 False comb_bkg_yield 1095 +/- 70 False part_reco_yield 7101 +/- 1.3e+02 -1.3e+02 +1.3e+02 False alpha_sig 300 +/- 1.4e+02 False mu_sig 370.8 +/- 1.4 - 1.4 + 1.4 False n sig 4 +/- 10 False sigma_sig 33.87 +/- 1.3 False #### What is 'new_result'? When profiling a likelihood, such as done in the algorithm used in `errors`, a new minimum can be found. If this is the case, this new minimum will be returned, otherwise `new_result` is `None`. Furthermore, the current `result` would be rendered invalid by setting the flag `valid` to `False`. _Note_: this behavior only applies to the zfit internal error estimator. ### A simple profile There is no default function (yet) for simple profiling plot. However, again, we're in Python and it's simple enough to do that for a parameter. Let's do it for `sig_yield` ```python x = np.linspace(1600, 2000, num=50) y = [] sig_yield.floating = False for val in x: sig_yield.set_value(val) y.append(nll.value()) sig_yield.floating = True zfit.param.set_values(nll.get_params(), result) ``` <zfit.util.temporary.TemporarilySet at 0x7f16cc8d7550> ```python plt.plot(x, y) ``` We can also access the covariance matrix of the parameters ```python result.covariance() ``` array([[ 4.92114494e+03, 1.14332473e+03, -4.33133015e+03, 0.00000000e+00, -1.99905281e+01, 0.00000000e+00, 4.04511667e+01], [ 1.14332473e+03, 4.94928342e+03, -5.67290390e+03, 0.00000000e+00, -6.88067541e+00, 0.00000000e+00, 1.48550756e+01], [-4.33133015e+03, -5.67290390e+03, 1.73736782e+04, 0.00000000e+00, 2.77291911e+01, 0.00000000e+00, -5.58205907e+01], [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 2.00000000e+04, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00], [-1.99905281e+01, -6.88067541e+00, 2.77291911e+01, 0.00000000e+00, 1.86637825e+00, 0.00000000e+00, -3.46142640e-01], [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 1.01400000e+02, 0.00000000e+00], [ 4.04511667e+01, 1.48550756e+01, -5.58205907e+01, 0.00000000e+00, -3.46142640e-01, 0.00000000e+00, 1.60027149e+00]]) # End of zfit This is where zfit finishes and other libraries take over. # Beginning of hepstats `hepstats` is a library containing statistical tools and utilities for high energy physics. In particular you do statistical inferences using the models and likelhoods function constructed in `zfit`. Short example: let's compute for instance a confidence interval at 68 % confidence level on the mean of the gaussian defined above. ```python from hepstats.hypotests.parameters import POIarray from hepstats.hypotests.calculators import AsymptoticCalculator from hepstats.hypotests import ConfidenceInterval ``` ```python calculator = AsymptoticCalculator(input=result, minimizer=minimizer) ``` ```python value = result.params[mu_sig]["value"] error = result.params[mu_sig]["minuit_hesse"]["error"] mean_scan = POIarray(mu_sig, np.linspace(value - 1.5*error, value + 1.5*error, 10)) ``` ```python ci = ConfidenceInterval(calculator, mean_scan) ``` ```python ci.interval() ``` Confidence interval on mu_sig: 369.42424650773955 < mu_sig < 372.1404588905455 at 68.0% C.L. {'observed': 370.7878667059073, 'upper': 372.1404588905455, 'lower': 369.42424650773955} ```python from utils import one_minus_cl_plot ax = one_minus_cl_plot(ci) ax.set_xlabel("mean") ``` There will be more of `hepstats` later.
b00b392978a7224fab32ff55c40d9292dc6918f0
170,262
ipynb
Jupyter Notebook
tutorial2_zfit/Introduction.ipynb
zfit/python_hpc_TensorFlow_MSU
a866b63ddf59c773d89b7e499625bd1eb3d70cb0
[ "BSD-3-Clause" ]
1
2020-10-10T13:34:04.000Z
2020-10-10T13:34:04.000Z
tutorial2_zfit/Introduction.ipynb
zfit/python_hpc_TensorFlow_MSU
a866b63ddf59c773d89b7e499625bd1eb3d70cb0
[ "BSD-3-Clause" ]
null
null
null
tutorial2_zfit/Introduction.ipynb
zfit/python_hpc_TensorFlow_MSU
a866b63ddf59c773d89b7e499625bd1eb3d70cb0
[ "BSD-3-Clause" ]
null
null
null
89.049163
26,560
0.823449
true
9,792
Qwen/Qwen-72B
1. YES 2. YES
0.72487
0.699254
0.506869
__label__eng_Latn
0.972054
0.015955
# Cálculo e clasificación de puntos críticos Con todas as ferramentas que xa levamos revisado nas anteriores prácticas, o cálculo de puntos críticos e a súa clasificación mediante o criterio que involucra á matriz Hessiana de funcións de dúas variables diferenciables é moi sinxelo usando o módulo **Sympy**. No caso de puntos críticos basta calcular o gradiente da función e resolver un sistema de dúas ecuacións (habitualmente non lineal) e para a clasificación dos puntos críticos se deben inspeccionar os autovalores da matriz Hessiana (cálculo que tamén está dispoñible en **Sympy**). Como aplicación do cálculo e identificación de máximos e mínimos relativos, revisaremos como interpretar como un problema de optimización o axuste polinomial mediante mínimos cadrados dun conxunto de puntos unidimensional. ### Obxectivos: - Cálculo de puntos críticos - Clasificación de puntos críticos: matriz Hessiana - Problema de optimización: axuste polinomial mediante mínimos cadrados ## Cálculo de puntos críticos Nesta práctica usaremos tanto o módulo **Sympy**, como tamén **Numpy** e **Matplotlib**. Así que debemos importalos para o resto do guión de prácticas: ```python import sympy as sp import numpy as np import matplotlib.pyplot as plt ``` Como xa aconteceu en prácticas anteriores, debemos facer unha implementación propia para calcular o gradiente dunha función escalar $f$. Para iso usaremos a relación que xa coñecemos entre a matriz Xacobiana $Df$ dunha función escalar e o vector (columna) gradiente $\nabla f$, isto é $\nabla f=Df^{t}$: ```python gradient = lambda f, v: sp.transpose(sp.Matrix([f]).jacobian(v)) ``` Como xa estudamos nas sesións expositivas, que se supoñemos que a función de dúas variables $f$ é diferenciable, o cálculo de puntos críticos realízase tendo en conta que o plano tanxente á superficie que define a función son planos horizontais nos extremos relativos da función, é dicir, naqueles puntos onde as derivadas parciais de $f$ son nulas. Vexamos isto cun exemplo no que $f(x,y)=-x^3 +4xy-2y^2+1$: ```python x, y = sp.symbols('x y', real=True) # define as variables simbólicas x e y f = sp.Lambda((x,y), -x**3 +4*x*y-2*y**2+1) # Cálculo de puntos críticos grad_f = gradient(f(x,y),(x,y)) sol = sp.solve((sp.Eq(grad_f[0],0),sp.Eq(grad_f[1],0)),(x,y)) display('Critical points for x and y:', sol) ``` 'Critical points for x and y:' [(0, 0), (4/3, 4/3)] Para comprobar visualmente o tipo de puntos críticos que posúe esta función, a podemos representar gráficamente: ```python p = sp.plotting.plot3d(f(x,y), (x, -2, 2), (y, -2, 2), show=False) p.xlabel='x' p.ylabel='y' p.zlabel='z' p.show() ``` ### **Exercicio 8.1** Calcula os puntos críticos e representa graficamente a función: $$ f(x,y) = \left(\frac12-x^2+y^2\right)e^{1-x^2-y^2} $$ na rexión $(x,y)\in[-4,4]\times[-4,4]$. ```python # O TEU CÓDIGO AQUÍ ``` ## Clasificación de puntos críticos: matriz Hessiana O cálculo da matriz Hessiana co módulo **Sympy** é inmediato xa que basta usar o comando `sp.hessian`. Unha vez feito isto, para calcular os autovalores desta matriz e decidir atendendo aos seus valores sen os puntos críticos son máximos relativos, mínimos relativos ou puntos de sela, soamnete debemos empregar o método `eigenvals` que está accesible na clase de obxectos tipo `sp.Matrix`: ```python H = sp.Lambda((x,y), sp.hessian(f(x,y), (x,y))) display('Hessian matrix', H(x,y)) # Clasificación do primeiro punto crítico: (0,0) eigs = H(*sol[0]).eigenvals() display('Eigenvalues for point (0,0)', np.double([*eigs])) # Clasificación do segundo punto crítico: (4/3,4/3) eigs = H(*sol[1]).eigenvals() display('Eigenvalues for point (4/3,4/3)', np.double([*eigs])) ``` 'Hessian matrix' $\displaystyle \left[\begin{matrix}- 6 x & 4\\4 & -4\end{matrix}\right]$ 'Eigenvalues for point (0,0)' array([-6.47213595, 2.47213595]) 'Eigenvalues for point (4/3,4/3)' array([-10.47213595, -1.52786405]) ### **Exercicio 8.2** Clasifica os puntos críticos obtidos no exercicio 8.1, que correspondían á función: $$ f(x,y) = \left(\frac12-x^2+y^2\right)e^{1-x^2-y^2} $$ na rexión $(x,y)\in[-4,4]\times[-4,4]$. ```python # O TEU CÓDIGO AQUÍ ``` ## Axuste polinomial mediante mínimos cadrados Dado un conxunto de puntos nun plano $(x_1,y_1), (x_2,y_2),\ldots, (x_{m},y_{m})$, é habitual que se trate atopar cal é o mellor polinomio de grao $N$ que minimiza o erro cadrático medio entre os datos proporcionados e os valores do polinomio axustado. No caso, dunh polinomio de grado $1$, o polinomio se escribe como $p(x)=ax+b$ e o anterior problema redúcese a atopar $(a^*,b^*)$ tal que se minimiza a función error: $$ \mathrm{error}(a^*,b^*)=\min_{(a,b)\in\mathbb{R}^{2}}\mathrm{error}(a,b) $$ onde $$ \mathrm{error}(a,b)=\sum_{i=1}^{m}(ax_i+b-y_i)^2. $$ Como calquera outro problema de minimización sen restriccións, para a súa resolución se deben calcular os puntos críticos da función erro e despois comprobar que se trata dun mínimo relativo (que será absoluto xa que a función erro tende a infinito cando $a$ ou $b$ tenden a $\pm\infty$). Vexamos este cálculo cun exemplo concreto. En primeiro lugar introducimos os datos: ```python # Datos xdata = np.array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0]) ydata = np.array([0.0, 0.8, 0.9, 0.1, -0.8, -1.0]) ``` A continuación, definimos a función error, calculamos os puntos críticos e mediante a matriz Hessiana determinamos que se trata dun mínimo relativo. ```python # Erro a minimizar no método de mínimos cadrados a, b = sp.symbols('a b', real=True) error = sp.Lambda((a,b),sum((a*xi + b - yi)**2 for xi,yi in zip(xdata, ydata))) display('Error function', error(a,b)) # Cálculo de puntos críticos grad_error = gradient(error(a,b),(a,b)) sol = sp.solve((sp.Eq(grad_error[0],0),sp.Eq(grad_error[1],0)),(a,b)) display('Critical points for a and b:', sol) # Clasificación de puntos críticos: autovalores da matriz Hessiana H = sp.hessian(error(a,b), (a,b)) display('Hessian matrix', H) eigs = H.eigenvals() display('Eigenvalues', [*eigs]) display('Eigenvalues', np.double([*eigs])) ``` 'Error function' $\displaystyle b^{2} + \left(1.0 a + b - 0.8\right)^{2} + \left(2.0 a + b - 0.9\right)^{2} + \left(3.0 a + b - 0.1\right)^{2} + \left(4.0 a + b + 0.8\right)^{2} + \left(5.0 a + b + 1.0\right)^{2}$ 'Critical points for a and b:' {a: -0.302857142857143, b: 0.757142857142857} 'Hessian matrix' $\displaystyle \left[\begin{matrix}110.0 & 30.0\\30.0 & 12\end{matrix}\right]$ 'Eigenvalues' [61 - sqrt(3301), sqrt(3301) + 61] 'Eigenvalues' array([ 3.54567031, 118.45432969]) Dado que o proceso de axuste polinomial de datos é unha tarefa moi recurrente, existen métodos numéricos dedicados ao seu cálculo (tanto nunha como en varias dimensións). En particular, o módulo **Numpy** tamén ten un ferramenta directa para facer este axuste co comando `np.polyfit`. Comprobemos que os coeficientes que calcula son os mesmos que se obteñen cos cálculos en **Sympy**: ```python # Axuste por mínimos cadrados dun polinomio de orde 1 z = np.polyfit(xdata, ydata, 1) display('Values for a and b', z) ``` 'Values for a and b' array([-0.30285714, 0.75714286]) Adicionalmente, o comando `np.polyfit` permite facer o axuste usando un polinomo de calquera orde. No que segue, se calcula e representa graficamente o axuste polinomial de orde $3$: ```python # Axuste por mínimos cadrados dun polinomio de orde 3 z = np.polyfit(xdata, ydata, 3) # Define un polinomio en Sympy a partir dos seus coeficientes x = sp.symbols('x', real=True) P = sp.Lambda(x,sum((a*x**i for i,a in enumerate(z[::-1])))) # Representación gráfica pol = sp.lambdify(x,P(x),"numpy") plt.plot(xdata, ydata, '.', label='Data') xp = np.linspace(-1.,6.,100) plt.plot(xp, pol(xp), '-', label='Fitting') plt.xlim(-1,6) plt.ylim(-2,2) plt.legend() plt.show() ``` ### **Exercicio 8.3** Sobre os datos usados anteriormente, sábese que no punto $x=4.5$, o valor é $-1.01$. Usa diferente orde de polinomios para axustar os datos, por exemplo $N=3, 5, 10, 20, 30$. Calcula o erro que se comete neste axuste no punto $x=4.5$: - Ao aumentar a orde polinomial, mellorase o erro? - Cal é o valor de $N$ co que se comete menor erro no axuste para o punto $x=4.5$? - Ao introducir o novo dato do punto $x=4.5$ e usar $N<4$: apreciase algunha diferencia na curva axustada? ```python # O TEU CÓDIGO AQUÍ ```
5ff0a30107d820b79eda1a3b90654559cfe0816f
112,842
ipynb
Jupyter Notebook
practicas/extremos-relativos.ipynb
maprieto/CalculoMultivariable
6bd7839803d696c6cd0e3536c0631453eacded70
[ "MIT" ]
1
2021-01-09T18:30:54.000Z
2021-01-09T18:30:54.000Z
practicas/extremos-relativos.ipynb
maprieto/CalculoMultivariable
6bd7839803d696c6cd0e3536c0631453eacded70
[ "MIT" ]
null
null
null
practicas/extremos-relativos.ipynb
maprieto/CalculoMultivariable
6bd7839803d696c6cd0e3536c0631453eacded70
[ "MIT" ]
null
null
null
307.47139
82,555
0.905718
true
2,880
Qwen/Qwen-72B
1. YES 2. YES
0.833325
0.737158
0.614292
__label__glg_Latn
0.970904
0.265537
# Constrained optimization Now we will move to studying constrained optimizaton problems i.e., the full problem $$ \begin{align} \ \min \quad &f(x)\\ \text{s.t.} \quad & g_j(x) \geq 0\text{ for all }j=1,\ldots,J\\ & h_k(x) = 0\text{ for all }k=1,\ldots,K\\ &a_i\leq x_i\leq b_i\text{ for all } i=1,\ldots,n\\ &x\in \mathbb R^n, \end{align} $$ where for all $i=1,\ldots,n$ it holds that $a_i,b_i\in \mathbb R$ or they may also be $-\infty$ of $\infty$. For example, we can have an optimization problem $$ \begin{align} \ \min \quad &x_1^2+x_2^2\\ \text{s.t.} \quad & x_1+x_2-1\geq 0\\ &-1\leq x_1\leq 1, x_2\leq 3.\\ \end{align} $$ In order to optimize that problem, we can define the following python function: ```python import numpy as np def f_constrained(x): return np.linalg.norm(x)**2,[x[0]+x[1]-1],[] ``` Now, we can call the function: ```python (f_val,ieq,eq) = f_constrained([1,0]) print "Value of f is "+str(f_val) if len(ieq)>0: print "The values of inequality constraints are:" for ieq_j in ieq: print str(ieq_j)+", " if len(eq)>0: print "The values of the equality constraints are:" for eq_k in eq: print str(eq_k)+", " ``` Value of f is 1.0 The values of inequality constraints are: 0, Is this solution feasible? ```python if all([ieq_j>=0 for ieq_j in ieq]) and all([eq_k==0 for eq_k in eq]): print "Solution is feasible" else: print "Solution is infeasible" ``` Solution is feasible # Indirect and direct methods for constrained optimization There are two categories of methods for constrained optimization: Indirect and direct methods. The main difference is that 1. Indirect methods convert the constrained optimization problem into a single or a sequence of unconstrained optimization problems, that are then solved. Often, the intermediate solutions do not need to be feasbiel, the sequence of solutions converges to a solution that is optimal (and, thus, feasible). 2. Direct methods deal with the constrained optimization problem directly. In this case, the intermediate solutions are feasible. # Indirect methods ## Penalty function methods **IDEA:** Include constraints into the objective function with the help of penalty functions that penalize constraint violations. Let, $\alpha(x):\mathbb R^n\to\mathbb R$ be a function so that * $\alpha(x)=$ for all feasible $x$ * $\alpha(x)>0$ for all infeasible $x$. Define optimization problems $$ \begin{align} \ \min \qquad &f(x)+r\alpha(x)\\ \text{s.t.} \qquad &x\in \mathbb R^n \end{align} $$ for $r>0$ and $x_r$ be the optimal solutions of these problems. In this case, the optimal solutions $x_r$ converge to the optimal solution of the constrained problem, when $r\to\infty$, if such solution exists. For example, good ideas for penalty functions are * $h_k(x)^2$ for equality constraints, * $\left(\min\{0,g_j(x)\}\right)^2$ for inequality constraints. ```python def alpha(x,f): (_,ieq,eq) = f(x) return sum([min([0,ieq_j])**2 for ieq_j in ieq])+sum([eq_k**2 for eq_k in eq]) ``` ```python alpha([1,0],f_constrained) ``` 0 ```python def penalized_function(x,f,r): return f(x)[0] + r*alpha(x,f) ``` ```python penalized_function([-1,0],f_constrained,10000) ``` 40001.0 ```python from scipy.optimize import minimize res = minimize(lambda x:penalized_function(x,f_constrained,100000), [0,0],method='Nelder-Mead', options={'disp': True}) print res.x ``` Optimization terminated successfully. Current function value: 0.499998 Iterations: 57 Function evaluations: 96 [ 0.49994305 0.50005243] ```python (f_val,ieq,eq) = f_constrained(res.x) print "Value of f is "+str(f_val) if len(ieq)>0: print "The values of inequality constraints are:" for ieq_j in ieq: print str(ieq_j)+", " if len(eq)>0: print "The values of the equality constraints are:" for eq_k in eq: print str(eq_k)+", " if all([ieq_j>=0 for ieq_j in ieq]) and all([eq_k==0 for eq_k in eq]): print "Solution is feasible" else: print "Solution is infeasible" ``` Value of f is 0.49999548939 The values of inequality constraints are: -4.51660156242e-06, Solution is infeasible ### How to set the penalty term $r$? The penalty term should * be large enough in order for the solutions be close enough to the feasible region, but * not be too large to * cause numerical problems, or * cause premature convergence to non-optimal solutions because of relative tolerances. Usually, the penalty term is either * set as big as possible without causing problems (hard to know), or * updated iteratively. # Barrier function methods **IDEA:** Prevent leaving the feasible region so that the value of the objective is $\infty$ outside the feasible set. This method is only applicable to problems with inequality constraints and for which the set $$\{x\in \mathbb R^n: g_j(x)>0\text{ for all }j=1,\ldots,J\}$$ is non-empty. Let $\beta:\{x\in \mathbb R^n: g_j(x)>0\text{ for all }j=1,\ldots,J\}\to \mathbb R$ be a function so that $\beta(x)\to \infty$, when $x\to\partial\{x\in \mathbb R^n: g_j(x)>0\text{ for all }j=1,\ldots,J\}$, where $\partial A$ is the boundary of the set $A$. Now, define optimization problem $$ \begin{align} \min \qquad & f(x) + r\beta(x)\\ \text{s.t. } \qquad & x\in \{x\in \mathbb R^n: g_j(x)>0\text{ for all }j=1,\ldots,J\}. \end{align} $$ and let $x_r$ be the optimal solution of this problem (which we assume to exist for all $r>0$). In this case, $x_r$ converges to the optimal solution of the problem (if it exists), when $r\to 0^+$ (i.e., $r$ converges to zero from the right). A good idea for barrier algorithm is $\frac1{g_j(x)}$. ```python def beta(x,f): _,ieq,_ = f(x) try: value=sum([1/max([0,ieq_j]) for ieq_j in ieq]) except ZeroDivisionError: value = float("inf") return value ``` ```python def function_with_barrier(x,f,r): return f(x)[0]+r*beta(x,f) ``` ```python from scipy.optimize import minimize res = minimize(lambda x:function_with_barrier(x,f_constrained,0.00000000000001), [1,1],method='Nelder-Mead', options={'disp': True}) print res.x ``` Optimization terminated successfully. Current function value: 0.500000 Iterations: 78 Function evaluations: 136 [ 0.49998927 0.50001085] ```python (f_val,ieq,eq) = f_constrained(res.x) print "Value of f is "+str(f_val) if len(ieq)>0: print "The values of inequality constraints are:" for ieq_j in ieq: print str(ieq_j)+", " if len(eq)>0: print "The values of the equality constraints are:" for eq_k in eq: print str(eq_k)+", " if all([ieq_j>=0 for ieq_j in ieq]) and all([eq_k==0 for eq_k in eq]): print "Solution is feasible" else: print "Solution is infeasible" ``` Value of f is 0.500000122097 The values of inequality constraints are: 1.21864303093e-07, Solution is feasible ## Other notes about using penalty and barrier function methods * It is worthwile to consider whether feasibility can be compromized. If the constraints do not have any tolerances, then barrier function method should be considered. * Also barrier methods parameter can be set iteratively * Penalty and barrier functions should be chosen so that they are differentiable (thus $x^2$ above) * In both methods, the minimum is attained at the limit. * Different penalty and barrier parameters can be used for differnt constraints, even for same problem.
45256d4d304a6853e389d2698bef91a04485aac0
14,539
ipynb
Jupyter Notebook
Lecture 6, Indirect methods for constrained optimization.ipynb
maeehart/TIES483
cce5c779aeb0ade5f959a2ed5cca982be5cf2316
[ "CC-BY-3.0" ]
4
2019-04-26T12:46:14.000Z
2021-11-23T03:38:59.000Z
Lecture 6, Indirect methods for constrained optimization.ipynb
maeehart/TIES483
cce5c779aeb0ade5f959a2ed5cca982be5cf2316
[ "CC-BY-3.0" ]
null
null
null
Lecture 6, Indirect methods for constrained optimization.ipynb
maeehart/TIES483
cce5c779aeb0ade5f959a2ed5cca982be5cf2316
[ "CC-BY-3.0" ]
6
2016-01-08T16:28:11.000Z
2021-04-10T05:18:10.000Z
25.285217
321
0.528578
true
2,227
Qwen/Qwen-72B
1. YES 2. YES
0.94079
0.897695
0.844543
__label__eng_Latn
0.981543
0.800488
# Laboratorio de física con Python ## Temario * Simulación de ODE (de primer orden) [Proximamente, de orden superior!) * Análisis de datos - Transformación de datos, filtrado - Ajuste de modelos - Integración - Derivación * Adquisición de datos * Gráficos Importamos librerías: _numpy_ para análisis numérico, _scipy_ para funciones de integración y ajuste, y _matplotlib_ para graficar. De paso, definimos características de ploteo. ```python import numpy as np import scipy as sp import matplotlib.pyplot as plt from matplotlib import animation import scipy.optimize as opt %matplotlib inline #Estilos de los gráficos de matplotlib. plt.rcParams["figure.figsize"] = (5 * (1 + np.sqrt(5)) / 2, 5) plt.rcParams["lines.linewidth"] = 2.5 plt.rcParams["ytick.labelsize"] = 12 plt.rcParams["xtick.labelsize"] = 12 plt.rcParams["axes.labelsize"] = 20 plt.rcParams["axes.grid"] = True ``` ## Explicación del circuito En este taller vamos a analizar el siguiente circuito, que corresponde a un RC Para encontrar la tensión en el capacitor usamos la segunda ley de Kirchoff, que nos dice que $v_{in} = v_{R} + v_{c}$ $ v_{in}(t) = R\;i(t) + \frac{1}{C} \int_{0}^{t} i(\tau) d\tau $ que si derivamos respecto al tiempo y multiplicamos por $C$, finalmente llegamos a la ecuación diferencial $$ RC \; \frac{d i(t)}{dt} + i(t) = C \frac{d v_{in}(t)}{dt} $$ Para una señal escalón, que se simula con una señal cuadrada, se puede demostrar (ver https://en.wikipedia.org/wiki/Heaviside_step_function) que la derivada es nula para $t>0$, que es el tiempo que nos importa, por lo que vamos a resolver finalmente la siguiente ecuación $$ RC \; \frac{d i(t)}{dt} + i(t) = 0 $$ $$\frac{d i(t)}{dt} = - \frac{1}{RC} i(t)$$ Pasemos a la simulación propiamente dicha, para lo que definimos el parámetro $$\tau = RC$$ ## Análisis de datos Adquiridos datos o ya adquiridos, vamos a analizarlos. ```python data = np.loadtxt("RC.csv") #Traigo datos ya adquiridos ``` ```python print(type(data)) #print(dir(data)) #Permite graficar las funciones del ndarray print(data) ``` <class 'numpy.ndarray'> [[ 8.00000000e+00 2.70000000e+01] [ 1.28000000e+02 9.40000000e+01] [ 2.48000000e+02 1.58000000e+02] [ 3.68000000e+02 2.16000000e+02] [ 4.88000000e+02 2.71000000e+02] [ 6.08000000e+02 3.22000000e+02] [ 7.28000000e+02 3.69000000e+02] [ 8.48000000e+02 4.14000000e+02] [ 9.68000000e+02 4.55000000e+02] [ 1.08800000e+03 4.93000000e+02] [ 1.20800000e+03 5.29000000e+02] [ 1.32800000e+03 5.63000000e+02] [ 1.44800000e+03 5.94000000e+02] [ 1.56800000e+03 6.23000000e+02] [ 1.68800000e+03 6.50000000e+02] [ 1.81600000e+03 6.77000000e+02] [ 1.93600000e+03 7.00000000e+02] [ 2.05600000e+03 7.22000000e+02] [ 2.17600000e+03 7.43000000e+02] [ 2.29600000e+03 7.62000000e+02] [ 2.41600000e+03 7.79000000e+02] [ 2.53600000e+03 7.96000000e+02] [ 2.65600000e+03 8.11000000e+02] [ 2.77600000e+03 8.25000000e+02] [ 2.89600000e+03 8.39000000e+02] [ 3.01600000e+03 8.51000000e+02] [ 3.13600000e+03 8.63000000e+02] [ 3.25600000e+03 8.74000000e+02] [ 3.37600000e+03 8.84000000e+02] [ 3.49600000e+03 8.93000000e+02] [ 3.61600000e+03 9.02000000e+02] [ 3.73600000e+03 9.11000000e+02] [ 3.85600000e+03 9.18000000e+02] [ 3.97600000e+03 9.25000000e+02] [ 4.09600000e+03 9.32000000e+02] [ 4.21600000e+03 9.38000000e+02] [ 4.33600000e+03 9.44000000e+02] [ 4.45600000e+03 9.49000000e+02] [ 4.57600000e+03 9.54000000e+02] [ 4.69600000e+03 9.59000000e+02] [ 4.81600000e+03 9.63000000e+02] [ 4.93600000e+03 9.67000000e+02] [ 5.05600000e+03 9.71000000e+02] [ 5.17600000e+03 9.74000000e+02] [ 5.29600000e+03 9.78000000e+02] [ 5.41600000e+03 9.81000000e+02] [ 5.53600000e+03 9.84000000e+02] [ 5.65600000e+03 9.86000000e+02] [ 5.77600000e+03 9.89000000e+02] [ 5.89600000e+03 9.91000000e+02] [ 6.01600000e+03 9.93000000e+02] [ 6.13600000e+03 9.95000000e+02] [ 6.25600000e+03 9.97000000e+02] [ 6.37600000e+03 9.99000000e+02] [ 6.49600000e+03 1.00100000e+03] [ 6.61600000e+03 1.00200000e+03] [ 6.73600000e+03 1.00400000e+03] [ 6.85600000e+03 1.00500000e+03] [ 6.97600000e+03 1.00600000e+03] [ 7.09600000e+03 1.00700000e+03] [ 7.21600000e+03 1.00800000e+03] [ 7.33600000e+03 1.00900000e+03] [ 7.45600000e+03 1.01000000e+03] [ 7.57600000e+03 1.01100000e+03] [ 7.70400000e+03 9.94000000e+02] [ 7.82400000e+03 9.26000000e+02] [ 7.94400000e+03 8.63000000e+02] [ 8.06400000e+03 8.04000000e+02] [ 8.18400000e+03 7.49000000e+02] [ 8.30400000e+03 6.98000000e+02] [ 8.42400000e+03 6.51000000e+02] [ 8.54400000e+03 6.07000000e+02] [ 8.66400000e+03 5.66000000e+02] [ 8.78400000e+03 5.27000000e+02] [ 8.90400000e+03 4.92000000e+02] [ 9.02400000e+03 4.58000000e+02] [ 9.14400000e+03 4.27000000e+02] [ 9.26400000e+03 3.98000000e+02] [ 9.38400000e+03 3.71000000e+02] [ 9.50400000e+03 3.46000000e+02] [ 9.62400000e+03 3.22000000e+02] [ 9.74400000e+03 3.00000000e+02] [ 9.86400000e+03 2.80000000e+02] [ 9.98400000e+03 2.61000000e+02] [ 1.01040000e+04 2.43000000e+02] [ 1.02240000e+04 2.26000000e+02] [ 1.03440000e+04 2.11000000e+02] [ 1.04640000e+04 1.97000000e+02] [ 1.05840000e+04 1.83000000e+02] [ 1.07040000e+04 1.71000000e+02] [ 1.08240000e+04 1.54000000e+02] [ 1.10000000e+04 1.44000000e+02] [ 1.11400000e+04 1.33000000e+02] [ 1.12560000e+04 1.24000000e+02] [ 1.13760000e+04 1.16000000e+02] [ 1.14960000e+04 1.08000000e+02] [ 1.16160000e+04 1.00000000e+02] [ 1.17360000e+04 9.30000000e+01] [ 1.18560000e+04 8.70000000e+01] [ 1.19760000e+04 8.10000000e+01] [ 1.21120000e+04 7.50000000e+01] [ 1.22320000e+04 7.00000000e+01] [ 1.23520000e+04 6.50000000e+01] [ 1.24720000e+04 6.00000000e+01] [ 1.25920000e+04 5.60000000e+01] [ 1.27120000e+04 5.20000000e+01] [ 1.28320000e+04 4.90000000e+01] [ 1.29520000e+04 4.50000000e+01] [ 1.30720000e+04 4.20000000e+01] [ 1.31920000e+04 3.90000000e+01] [ 1.33120000e+04 3.60000000e+01] [ 1.34320000e+04 3.40000000e+01] [ 1.35520000e+04 3.10000000e+01] [ 1.36720000e+04 2.90000000e+01] [ 1.37920000e+04 2.70000000e+01] [ 1.39120000e+04 2.50000000e+01] [ 1.40320000e+04 2.30000000e+01] [ 1.41520000e+04 2.20000000e+01] [ 1.42720000e+04 2.00000000e+01] [ 1.43920000e+04 1.90000000e+01] [ 1.45120000e+04 1.70000000e+01] [ 1.46320000e+04 1.60000000e+01] [ 1.47520000e+04 1.50000000e+01] [ 1.48720000e+04 1.40000000e+01] [ 1.49920000e+04 1.30000000e+01] [ 1.51120000e+04 1.20000000e+01] [ 1.52320000e+04 1.10000000e+01] [ 1.53520000e+04 1.00000000e+01]] Ahora imprimimos los datos. Como son dos tiras de datos, debemos imprimir varios ```python plt.plot(data[:,0], data[:,1], "ro-"); ``` Vamos a hacer un poco de análisis de datos, para eso, tomemos solamente una parte de la curva verde. Index slicing al rescate! Graficamos para revistar los resultados ```python #Hay varias opciones para sacar elementos #fitData = data[0:64] fitData = data[data[:, 0] < 7700] #Grafiquemos los resultados plt.plot(fitData[:,0], fitData[:,1], 'bo-') ``` Para ajustar el modelo, que sabemos que es $ V = V_0 ( 1 - e^{-B t}) $ primero construimos la función ```python f = lambda x, A, B, C: A * np.exp(- B * x) + C ``` Y luego usamos la función curve_fit de scipy ```python T = (fitData[:,0] - fitData[:,0].min()) * 1e-6 V = fitData[:,1] ErrV = 20 #Este error corresponde solamente al instrumental p0 = (-1023, 1000, 1024) p, cov = opt.curve_fit(f, T, V, p0) #Construyo una variable auxiliar del T t = np.linspace(T.min(), T.max(), 1000) plt.errorbar(T, V, yerr = ErrV, fmt = 'go') #plt.plot(T, V, 'go') plt.plot(t, f(t, *p), 'r-') #Grafico el ajuste #Presento de una manera "linda" el ajuste sigma = np.sqrt(np.diag(cov)) #la diagonal de la covarianza corresponde a la varianza, el "cuadrado del error" print("f = A exp(-B t) + C") print("A = {:.2f} +- {:.2f}".format(p[0], sigma[0])) #Le digo que ponga solo dos digitos después de la coma print("B = {:.2f} +- {:.2f}".format(p[1], sigma[1])) print("C = {:.2f} +- {:.2f}".format(p[2], sigma[2])) ``` La componentes corresponde a $R = (18,0 \pm 0,2)\text{k}\Omega$, $C = (0,10 \pm 0,01)\mu\text{F}$, con lo que la constante del circuito nos queda $\tau = \dfrac{1}{RC} = (555 \pm 62) $ que nos permite corresponder el modelo propuesto con lo experimental. También podemos ver la "bondad del ajuste", para lo que necesitamos el $\chi$-cuadrado. La función curve_fit no lo devuelve, pero podemos calcularlo rápidamente ```python chi2Red = (np.power((V - f(T, *p)) / np.sqrt(ErrV), 2)).sum()/(len(V) - 2) chi2Red ``` 0.0039539953544748853 Acá tenemos el $\chi$-cuadrado reducido, que debe ser cercano a 1. Si es mucho menor que 1, los errores están sobre dimensionados; si es mucho mayor a 1, el ajuste puede ser rechazado. Para cuantificar la palabra "mucho" podemos usar el p-valor con el test de $\chi$-cuadrado (https://en.wikipedia.org/wiki/Goodness_of_fit) ## Derivación e integración Ahora vamos a tomar datos para un integrador y un derivador. Para eso ejecuten la parte de adquisición de datos, si tienen el dispositivo, y obtengan los datos. Si no importenlos como ya hicimos ```python data = np.loadtxt("RC_int.csv") plt.plot(data[:,0], data[:,1], "ro-"); ``` Derivemos los datos para ver que resultado tenemos. Para eso tenemos la función de _numpy.diff_. Notar que al diferenciar el resultado tiene un dato menos, por lo que se debe eliminar del "vector tiempo" data[:,0] ```python plt.plot(data[:-1,0], np.diff(data[:,1]), 'go'); ``` Se "parece" a una cuadrada, creemos datos que representen a una cuadrada e integremoslos y comparandolos. Para eso, debemos usar la función _scipy.integrate.cumtrapz_. Luego reescalamos la señal integrada para compararla con la cuadrada ```python from scipy.integrate import cumtrapz T = data[:,0] N = int(data[:,1].shape[0] / 2) V = np.concatenate((np.full(N, 1), np.zeros(N) - 1)) plt.plot(T,V,'go') V_int = sp.integrate.cumtrapz(V, initial = 0) V_int /= V_int.max() plt.plot(T, V_int, 'ro') ``` Veamos ahora comparado los datos adquiridos respecto a la integración numérica, escalado para que sea comparable ```python plt.plot(data[:,0], data[:,1] / data[:,1].max(), 'bo', T, V_int, 'go') ``` Se nota que el circuito RC se acerca a la integración numérica, pero debido a lo que se conoce como ganancia del filtro RC y la constante de tiempo $\tau$ no se llega a obtener un integrador real. Para mejorar esto, en general, se debe usar circuitos activos (ver https://en.wikipedia.org/wiki/Active_filter), pero requieren más experiencia de diseño ## Simulación del circuito ### Simulación numérica Conociendo el comportamiento del circuito y la forma funcional de su derivada podemos usar las funciones que ya conocemos para simularlo. Recordemos que la ecuación diferencial había quedado como $ \dfrac{d i(t)}{dt} = - \dfrac{1}{\tau} i(t)$ Esto lo podemos escribir como ```python from scipy.integrate import odeint tau = 10 #Varien el parámetro y vean el resultado def f(y, t, tau): return (-y * tau) t = np.linspace(0, 1, 1000) y0 = [1] y = odeint(f, y0, t, args = (tau,)) plt.plot(t, y, 'r-'); ``` Recordemos que la ecuación diferencial que estamos resolviendo corresponde a la corriente del circuito. Si en vez de eso queremos la tensión del capacitor, debemos integrar este resultado, ya que $$ v_{c}(t) = \frac{1}{C} \int_{0}^{t} i(\tau) d\tau $$ Con la librería _scipy.integrate_, y la función _cumtrapz_, podemos integrar, ya que permite aplicar acumulativamente la regla del trapesoide. ```python from scipy.integrate import cumtrapz y_int = cumtrapz(y.ravel(), t) plt.plot(t[:-1], y_int.ravel(),'g-') ``` ### Simulación analítica Para completar, vamos a encontrar la expresión analítica de la corriente y la tensión del capacitor, que nos va a permitir determinar el modelo y ajustar los datos ```python #Usamos sympy, que tiene un tutorial muy completo en #http://docs.sympy.org/latest/tutorial/ #Nostros no hacemos más que repetir from sympy import symbols, Function, Eq, dsolve, integrate, collect_const #Creo los simbolos, es decir variables con significado simbolico t, tau = symbols('t, tau') i = symbols("i", cls=Function) diffEq = Eq(i(t).diff(t), -i(t)/tau) sol = dsolve(diffEq) sol ``` i(t) == C1*exp(-t/tau) Esta expresión es la corriente, para la tensión del capacitor, debemos integrar este resultado ```python C1, u, A = symbols('C1 u A') #Creo una variable de integración, la constante de integración y una variable A g = sol.rhs.subs(t, u) #Tomo la parte izquierda de la igualdad, y elimino t por u para integrar I = integrate(g, (u, 0, t)) collect_const(I.subs(tau*C1,A), A) #Esta función solo reodena el resultado, y remplazo tau*C1 -> A ``` A*(1 - exp(-t/tau)) Por lo que el modelo utilizado previamente es coherente con la solución de la ecuación diferencial. Con esto queda un pantallazo de toda la simulación, analítica y numérica, que se puede efectuar en Python. Nada mal ## Adquisición de datos Acá están las funciones para adquisición de datos. **No es necesario ejecutarlas**, pero si tenés un dispositivo serie que devuelva una lista de datos ASCII separada por tabulaciones (como ser algunos osciloscopios, por ejemplo), esto te va a permitir guardarlo!. Mientras, está pensado para utilizarlo con un [Arduino](http://www.arduino.cc), que fue programado por nosotros (y [acá está el código]() en Processing para ver que se hace). La librería _pandas_ tiene herramientas muy poderosas de análisis y filtrado de datos, pero es más de lo que necesitamos en general y usamos solamente _numpy_ ```python import io import time import serial import pandas as pd from serial.tools import list_ports def inputPort(): '''Obtiene la lista de puertos, la presenta en pantalla y da a elegir un puerto, devolviendo el string para conectarse ''' ports = list(list_ports.comports()) for i,p in enumerate(ports): print("[{}]: Puerto {}".format(i + 1, p[1])) port = "" if len(ports) > 0: port = ports[int(input("Ingrese el puerto serie: ")) - 1][0] return port def updateData(s): '''Obtiene los datos que manda el Arduino/Teensy por UART USB''' A = [] s.flushInput() s.write(b"1") time.sleep(2) while True: if ser.inWaiting() == 0: break A.append(s.read().decode()) A = "".join(A) data = pd.read_csv(io.StringIO(A),sep="\t",names=["t","v"]).dropna(axis=0) return data port = inputPort() ser = serial.Serial(port, "9600") data = updateData(ser).values ser.close() np.savetxt("data.csv", data) ``` Grafiquemos los datos para estar seguros de que obtenimos el resultado! ```python plt.plot(data[:,0], data[:,1], "ro-"); ``` Para complentar, reimplementamos la adquisición de datos, pero la hacemos un bucle y presentamos en tiempo real la adquisición, con un intervalo de refresco de 2s, aproximadamente ```python from IPython import display #Permite borrar la salida y volverla a cargar. Sirve para toda instancia de Ipython inputPort() ser = serial.Serial(port, "9600") data = updateData(ser).values ser.close() for i in range(50): plt.clf() data = update() plt.plot(data.t, data.V, "ro") display.clear_output(wait=True) display.display(plt.gcf()) #time.sleep(0.5) #Este delay no es necesario, ya está implementado en el update plt.close() ```
28dcb52ac12618a2eec3535582e5e3b44dd9023c
203,947
ipynb
Jupyter Notebook
python/Extras/Arduino/laboratorio.ipynb
LTGiardino/talleresfifabsas
a711b4425b0811478f21e6c405eeb4a52e889844
[ "MIT" ]
17
2015-10-23T17:14:34.000Z
2021-12-31T02:18:29.000Z
python/Extras/Arduino/laboratorio.ipynb
LTGiardino/talleresfifabsas
a711b4425b0811478f21e6c405eeb4a52e889844
[ "MIT" ]
5
2016-04-03T23:39:11.000Z
2020-04-03T02:09:02.000Z
python/Extras/Arduino/laboratorio.ipynb
LTGiardino/talleresfifabsas
a711b4425b0811478f21e6c405eeb4a52e889844
[ "MIT" ]
29
2015-10-16T04:16:01.000Z
2021-09-18T16:55:48.000Z
225.355801
26,954
0.890388
true
6,268
Qwen/Qwen-72B
1. YES 2. YES
0.894789
0.774583
0.693089
__label__spa_Latn
0.761206
0.448609
# Binet's Formula ## Formula Explicit formula to find the nth term of the Fibonacci sequence. $\displaystyle F_n = \frac{1}{\sqrt{5}} \Bigg(\Bigg( \frac{1 + \sqrt{5}}{2} \Bigg)^n - \Bigg( \frac{1 - \sqrt{5}}{2} \Bigg)^n \Bigg)$ *Derived by Jacques Philippe Marie Binet, alreday known by Abraham de Moivre* ---- ## Fibonacci Sequence The Fibonacci sequence iterates with the next value being the sum of the previous two: $F_{n+1} = F_n + F_{n-1}$ ```python def fib(n): a = b = 1 for _ in range(n): yield a a, b = b, a + b ", ".join([str(x) for x in fib(20)]) ``` '1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765' ---- ## Proof ### Fibonacci Ratios The ratios of the Fibanacci sequence $\displaystyle \lim_{n \rightarrow \infty} \frac{F_n}{F_{n-1}} = \varphi$ <br/> $\displaystyle \frac{F_n}{F_{n-1}}$ converges to the limit $\phi$ ```python def fib_ratio(n): a = b = 1 for _ in range(n): yield a/b a, b = b, a + b ", ".join(["{0:.6f}".format(x) for x in fib_ratio(20)]) ``` '1.000000, 0.500000, 0.666667, 0.600000, 0.625000, 0.615385, 0.619048, 0.617647, 0.618182, 0.617978, 0.618056, 0.618026, 0.618037, 0.618033, 0.618034, 0.618034, 0.618034, 0.618034, 0.618034, 0.618034' ### Compose as a Geometric Sequence This sequence resembles a geometric sequence. Geometric sequences have terms in the form of $G_n = a \cdot r^n$ . Therefore $F_{n+1} = F_n + F_{n-1} \implies a \cdot r^{n+1} = a \cdot r^n + a \cdot r^{n-1} \implies r^2 = r + 1$. ### Resolve Quadratic Using the Quadratic formula we find r as $1+\varphi$, or $\displaystyle\frac{1 \pm \sqrt{5}}{2}$ Let's declare $G_n = \displaystyle\frac{1 + \sqrt{5}}{2}$, and $H_n = \displaystyle\frac{1 - \sqrt{5}}{2}$ ```python # x^2−x−1=0 from sympy import * from sympy.plotting import plot from sympy.solvers import solve init_printing() x = symbols('x') exp = x**2 - x -1 plot(exp, (x, -2, 2)) answers = solve(x**2 -x -1, x) [ratsimp(a) for a in answers] ``` ### Conclusion Although neither $G_n$ and $H_n$ conform to the Fibonacci sequence, through induction, $G_n - H_n$ does. To find $a$, we can see that $F_0 = G_0 - H_0 = 0, and F_1 = G_1 - H_1 = 1 \implies a = \frac{1}{\sqrt{5}}$ ---- ## References - [Art of Problem Solving - Binet's Formula][3] - [Art of Problem Solving - Geometric Sequence][2] - [Art of Problem Solving - Fibonacci Sequence][1] [1]: https://artofproblemsolving.com/wiki/index.php?title=Fibonacci_sequence [2]: https://artofproblemsolving.com/wiki/index.php?title=Geometric_sequence [3]: https://artofproblemsolving.com/wiki/index.php?title=Binet%27s_Formula
6e6e90986c00390ebd9217509a085ab7b81c477e
21,750
ipynb
Jupyter Notebook
notebooks/math/number_theory/binets_formula.ipynb
sparkboom/my_jupyter_notes
9255e4236b27f0419cdd2c8a2159738d8fc383be
[ "MIT" ]
null
null
null
notebooks/math/number_theory/binets_formula.ipynb
sparkboom/my_jupyter_notes
9255e4236b27f0419cdd2c8a2159738d8fc383be
[ "MIT" ]
null
null
null
notebooks/math/number_theory/binets_formula.ipynb
sparkboom/my_jupyter_notes
9255e4236b27f0419cdd2c8a2159738d8fc383be
[ "MIT" ]
null
null
null
106.097561
14,436
0.849011
true
996
Qwen/Qwen-72B
1. YES 2. YES
0.913677
0.855851
0.781971
__label__eng_Latn
0.594059
0.655113
# Exercise 1 ## JIT the pressure poisson equation The equation we need to unroll is given by \begin{equation} p_{i,j}^{n} = \frac{1}{4}\left(p_{i+1,j}^{n}+p_{i-1,j}^{n}+p_{i,j+1}^{n}+p_{i,j-1}^{n}\right) - b \end{equation} and recall that `b` is already computed, so no need to worry about unrolling that. We've also filled in the boundary conditions, so don't worry about those. (don't forget to decorate your function!) ```python import numpy from numba import jit ``` ```python def pressure_poisson(p, b, l2_target=1e-4): I, J = b.shape iter_diff = l2_target + 1 n = 0 while iter_diff > l2_target and n <= 500: pn = p.copy() #Your code here #boundary conditions for i in range(I): p[i, 0] = p[i, 1] p[i, -1] = 0 for j in range(J): p[0, j] = p[1, j] p[-1, j] = p[-2, j] if n % 10 == 0: iter_diff = numpy.sqrt(numpy.sum((p - pn)**2)/numpy.sum(pn**2)) n += 1 return p ``` ```python import pickle from snippets.ns_helper import cavity_flow, velocity_term, quiver_plot ``` ```python def run_cavity(): nx = 41 with open('../IC.pickle', 'rb') as f: u, v, p, b = pickle.load(f) dx = 2 / (nx - 1) dt = .005 nt = 1000 u, v, p = cavity_flow(u, v, p, nt, dt, dx, velocity_term, pressure_poisson, rtol=1e-4) return u, v, p ``` ```python un, vn, pn = run_cavity() ``` ```python %timeit run_cavity() ``` ```python with open('../numpy_ans.pickle', 'rb') as f: u, v, p = pickle.load(f) ``` ```python assert numpy.allclose(u, un) assert numpy.allclose(v, vn) assert numpy.allclose(p, pn) ``` # Exercise 2 (optional) Finish early? Just want to try more stuff? This line is not super efficient: ```python iter_diff = numpy.sqrt(numpy.sum((p - pn)**2)/numpy.sum(pn**2)) ``` Try rewriting it using a jitted function and see what kind of performance gain you can get. ```python ```
0e5936f7cf5cec621e0e31c2a188ada3e097a3e4
4,223
ipynb
Jupyter Notebook
notebooks/exercises/05.Cavity.Flow.Exercises.ipynb
gforsyth/numba_tutorial_scipy2017
01befd25218783f6d3fb803f55dd9e52f6072ff7
[ "CC-BY-4.0" ]
131
2017-06-23T10:18:26.000Z
2022-03-27T21:16:56.000Z
notebooks/exercises/05.Cavity.Flow.Exercises.ipynb
gforsyth/numba_tutorial_scipy2017
01befd25218783f6d3fb803f55dd9e52f6072ff7
[ "CC-BY-4.0" ]
9
2017-06-11T21:20:59.000Z
2018-10-18T13:57:30.000Z
notebooks/exercises/05.Cavity.Flow.Exercises.ipynb
gforsyth/numba_tutorial_scipy2017
01befd25218783f6d3fb803f55dd9e52f6072ff7
[ "CC-BY-4.0" ]
64
2017-06-26T13:04:48.000Z
2022-01-11T20:36:31.000Z
23.461111
206
0.460336
true
653
Qwen/Qwen-72B
1. YES 2. YES
0.880797
0.888759
0.782816
__label__eng_Latn
0.89803
0.657077
```python from sympy import * from IPython.display import display, Latex, HTML, Markdown init_printing() from eqn_manip import * from codegen_extras import * import codegen_extras from importlib import reload from sympy.codegen.ast import Assignment, For, CodeBlock, real, Variable, Pointer, Declaration from sympy.codegen.cnodes import void ``` ## Cubic Spline solver - derivation and code generation ### Tridiagonal Solver From Wikipedia: https://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm In the future it would be good to derive these equations from Gaussian elimintation (as on the Wikipedia page), but for now they are simply given. ```python n = Symbol('n', integer=True) i = Symbol('i', integer=True) x = IndexedBase('x',shape=(n,)) dp = IndexedBase("d'",shape=(n,)) cp = IndexedBase("c'",shape=(n,)) a = IndexedBase("a",shape=(n,)) b = IndexedBase("b",shape=(n,)) c = IndexedBase("c",shape=(n,)) d = IndexedBase("d",shape=(n,)) ``` ```python # forward sweep # start/end using the natural range for math notation #start = 1 #end = n # Use the C++ range 0,n-1 start = 0 end = n-1 teq1 = Eq(cp[start], c[start]/b[start]) display(teq1) teq2 = Eq(dp[start], d[start]/b[start]) display(teq2) teq3 = Eq(dp[i],(d[i] - dp[i-1]*a[i])/ (b[i] - cp[i-1]*a[i])) display(teq3) teq4 = Eq(cp[i],c[i]/(b[i] - cp[i-1]*a[i])) display(teq4) ``` $${c'}_{0} = \frac{{c}_{0}}{{b}_{0}}$$ $${d'}_{0} = \frac{{d}_{0}}{{b}_{0}}$$ $${d'}_{i} = \frac{- {a}_{i} {d'}_{i - 1} + {d}_{i}}{- {a}_{i} {c'}_{i - 1} + {b}_{i}}$$ $${c'}_{i} = \frac{{c}_{i}}{- {a}_{i} {c'}_{i - 1} + {b}_{i}}$$ ```python # backward sweep teq5 = Eq(x[end],dp[end]) display(teq5) teq6 = Eq(x[i],dp[i] - cp[i]*x[i+1]) display(teq6) ``` $${x}_{n - 1} = {d'}_{n - 1}$$ $${x}_{i} = - {c'}_{i} {x}_{i + 1} + {d'}_{i}$$ ### Cubic Spline equations Start with uniform knot spacing. The derivation is easier to see than in the case with general knot spacing. ```python # Distance from the previous knot, for the case of uniform knot spacing t = Symbol('t') # Number of knots n = Symbol('n', integer=True) i = Symbol('i', integer=True) # Function values to intepolated at the knots y = IndexedBase('y',shape=(n,)) # Coefficients of the spline function a,b,c,d = [IndexedBase(s, shape=(n,)) for s in 'a b c d'.split()] # Cubic spline function s = a + b*t + c*t*t + d*t**3 display(Eq(y,s)) # With indexed variables si = a[i] + b[i]*t + c[i]*t*t + d[i]*t**3 display(Eq(y[i],si)) ``` $$y = t^{3} d + t^{2} c + t b + a$$ $${y}_{i} = t^{3} {d}_{i} + t^{2} {c}_{i} + t {b}_{i} + {a}_{i}$$ ### Strategy To eventually reduce the equations to a tridiagonal form, express the equations in terms of the second derivative ($E$). See the MathWorld page for cubic splines, which derives the equations in terms of the first derivative ($D$). http://mathworld.wolfram.com/CubicSpline.html ```python # Value at knots (t=0) sp1 = Eq(si.subs(t,0), y[i]) sp1 ``` $${a}_{i} = {y}_{i}$$ ```python # Value at knots (t=1) sp2 = Eq(si.subs(t,1), y[i+1]) sp2 ``` $${a}_{i} + {b}_{i} + {c}_{i} + {d}_{i} = {y}_{i + 1}$$ ```python # Express the second derivative at the beginning of the interval in terms of E E = IndexedBase('E',shape=(n,)) sp3 = Eq(E[i], diff(si,t,2).subs(t,0)) sp3 ``` $${E}_{i} = 2 {c}_{i}$$ ```python # Express the second derivative at the end of the interval in terms of E sp4 = Eq(E[i+1], diff(si,t,2).subs(t,1)) sp4 ``` $${E}_{i + 1} = 2 {c}_{i} + 6 {d}_{i}$$ ```python # Continuity of the first derivative sp5 = Eq(diff(si,t).subs(t,1), diff(si,t).subs(t,0).subs(i,i+1)) sp5 ``` $${b}_{i} + 2 {c}_{i} + 3 {d}_{i} = {b}_{i + 1}$$ ### For general spacing of the knots ```python L = IndexedBase('L',shape=(n,)) # L[i] = x[i+1] - x[i] t = Symbol('t') x = IndexedBase('x',shape=(n,)) si = a[i] + b[i]*t + c[i]*t*t + d[i]*t**3 ``` ```python # Value at knots (t=0) sp1 = Eq(si.subs(t,0), y[i]) sp1 ``` $${a}_{i} = {y}_{i}$$ ```python # Value at next knot sp2 = Eq(si.subs(t,L[i]), y[i+1]) sp2 ``` $${L}_{i}^{3} {d}_{i} + {L}_{i}^{2} {c}_{i} + {L}_{i} {b}_{i} + {a}_{i} = {y}_{i + 1}$$ ```python # Express the second derivative at the beginning of the interval in terms of E E = IndexedBase('E',shape=(n,)) sp3 = Eq(E[i], diff(si,t,2).subs(t,0)) sp3 ``` $${E}_{i} = 2 {c}_{i}$$ ```python # Express the second derivative at the end of the interval in terms of E sp4 = Eq(E[i+1], diff(si,t,2).subs(t,L[i])) sp4 ``` $${E}_{i + 1} = 6 {L}_{i} {d}_{i} + 2 {c}_{i}$$ ```python # Solve for spline coefficients in terms of E's sln = solve([sp1,sp2,sp3,sp4], [a[i],b[i],c[i],d[i]]) sln ``` $$\left \{ {a}_{i} : {y}_{i}, \quad {b}_{i} : \frac{- \frac{\left({E}_{i + 1} + 2 {E}_{i}\right) {L}_{i}^{2}}{6} + {y}_{i + 1} - {y}_{i}}{{L}_{i}}, \quad {c}_{i} : \frac{{E}_{i}}{2}, \quad {d}_{i} : \frac{{E}_{i + 1} - {E}_{i}}{6 {L}_{i}}\right \}$$ ```python # also for i+1 sln1 = {k.subs(i,i+1):v.subs(i,i+1) for k,v in sln.items()} sln1 ``` $$\left \{ {a}_{i + 1} : {y}_{i + 1}, \quad {b}_{i + 1} : \frac{- \frac{\left(2 {E}_{i + 1} + {E}_{i + 2}\right) {L}_{i + 1}^{2}}{6} - {y}_{i + 1} + {y}_{i + 2}}{{L}_{i + 1}}, \quad {c}_{i + 1} : \frac{{E}_{i + 1}}{2}, \quad {d}_{i + 1} : \frac{- {E}_{i + 1} + {E}_{i + 2}}{6 {L}_{i + 1}}\right \}$$ ```python # Continuity of first derivatives at knots # This will define the tridiagonal system to be solved sp5 = Eq(diff(si,t).subs(t,L[i]), diff(si,t).subs(i, i+1).subs(t,0)) sp5 ``` $$3 {L}_{i}^{2} {d}_{i} + 2 {L}_{i} {c}_{i} + {b}_{i} = {b}_{i + 1}$$ ```python sp6 = sp5.subs(sln).subs(sln1) sp7 = expand(sp6) sp7 ``` $$\frac{{E}_{i + 1} {L}_{i}}{3} + \frac{{E}_{i} {L}_{i}}{6} + \frac{{y}_{i + 1}}{{L}_{i}} - \frac{{y}_{i}}{{L}_{i}} = - \frac{{E}_{i + 1} {L}_{i + 1}}{3} - \frac{{E}_{i + 2} {L}_{i + 1}}{6} - \frac{{y}_{i + 1}}{{L}_{i + 1}} + \frac{{y}_{i + 2}}{{L}_{i + 1}}$$ ```python sp8 = divide_terms(sp7, [E[i],E[i+1],E[i+2]], [y[i],y[i+1],y[i+2]]) display(sp8) sp9 = mult_eqn(sp8,6) display(sp9) # The index 'i' used in the cubic spline equations is not the same 'i' used # in the tridigonal solver. Here we need to make them match. # The first foundary condition will the equation at index at 0. # Adjust the indexing on this equation so i=1 is the index of the first continuity interval match sp9 = sp9.subs(i,i-1) ``` $$\frac{{E}_{i + 1} {L}_{i + 1}}{3} + \frac{{E}_{i + 1} {L}_{i}}{3} + \frac{{E}_{i + 2} {L}_{i + 1}}{6} + \frac{{E}_{i} {L}_{i}}{6} = - \frac{{y}_{i + 1}}{{L}_{i}} + \frac{{y}_{i}}{{L}_{i}} - \frac{{y}_{i + 1}}{{L}_{i + 1}} + \frac{{y}_{i + 2}}{{L}_{i + 1}}$$ $$2 {E}_{i + 1} {L}_{i + 1} + 2 {E}_{i + 1} {L}_{i} + {E}_{i + 2} {L}_{i + 1} + {E}_{i} {L}_{i} = - \frac{6 {y}_{i + 1}}{{L}_{i}} + \frac{6 {y}_{i}}{{L}_{i}} - \frac{6 {y}_{i + 1}}{{L}_{i + 1}} + \frac{6 {y}_{i + 2}}{{L}_{i + 1}}$$ ```python # Extract the three coefficients in each row for the general case symlist = [E[i-1],E[i],E[i+1],E[i+2]] coeff1 = get_coeff_for(sp9.lhs, E[i-1], symlist) display(coeff1) coeff2 = get_coeff_for(sp9.lhs, E[i], symlist) display(coeff2) coeff3 = get_coeff_for(sp9.lhs, E[i+1], symlist) display(coeff3) ``` $${L}_{i - 1}$$ $$2 {L}_{i - 1} + 2 {L}_{i}$$ $${L}_{i}$$ ```python # Now get the coefficients for the boundary conditions (first row and last row) # Natural BC bc_natural_start = Eq(E[i].subs(i,0),0) display(bc_natural_start) bc_natural_end = Eq(E[i].subs(i,end),0) display(bc_natural_end) # The coefficients and RHS for this BC are pretty simple. but we will follow # a deterministic path for derivation anyway. bc_natural_start_coeff1 = get_coeff_for(bc_natural_start.lhs, E[start],[E[start]]) display(bc_natural_start_coeff1) bc_natural_start_coeff2 = get_coeff_for(bc_natural_start.lhs, E[start+1],[E[start],E[start+1]]) display(bc_natural_start_coeff2) bc_natural_end_coeff1 = get_coeff_for(bc_natural_end.lhs, E[end-1],[E[end]]) display(bc_natural_end_coeff1) bc_natural_end_coeff2 = get_coeff_for(bc_natural_end.lhs, E[end],[E[end]]) bc_natural_end_coeff2 ``` $${E}_{0} = 0$$ $${E}_{n - 1} = 0$$ $$1$$ $$0$$ $$0$$ $$1$$ ```python # BC - first derivative specified at the beginning of the range yp0 = Symbol('yp0') eqbc1=Eq(diff(si,t).subs(t,0).subs(sln).subs(i,0), yp0) display(eqbc1) eqbc1b = divide_terms(expand(eqbc1),[E[0],E[1]],[y[0],y[1],yp0]) eqbc1c = mult_eqn(eqbc1b, 6) display(eqbc1c) bc_firstd_start_coeff1 = get_coeff_for(eqbc1c.lhs, E[0], [E[0],E[1]]) display(bc_firstd_start_coeff1) bc_firstd_start_coeff2 = get_coeff_for(eqbc1c.lhs, E[1], [E[0],E[1]]) display(bc_firstd_start_coeff2) ``` $$\frac{- \frac{\left(2 {E}_{0} + {E}_{1}\right) {L}_{0}^{2}}{6} - {y}_{0} + {y}_{1}}{{L}_{0}} = yp_{0}$$ $$- 2 {E}_{0} {L}_{0} - {E}_{1} {L}_{0} = 6 yp_{0} + \frac{6 {y}_{0}}{{L}_{0}} - \frac{6 {y}_{1}}{{L}_{0}}$$ $$- 2 {L}_{0}$$ $$- {L}_{0}$$ ```python # For the general algorithm, the input parameters for the boundary conditions are # - first derivative, if value is less than cutoff # - second derivative is zero, if vlaue is greater than cutoff bc_cutoff = 0.99e30 tbc_start_coeff1 = Piecewise((bc_firstd_start_coeff1, yp0 < bc_cutoff),(bc_natural_start_coeff1,True)) display(tbc_start_coeff1) tbc_start_coeff2 = Piecewise((bc_firstd_start_coeff2, yp0 < bc_cutoff),(bc_natural_start_coeff2,True)) display(tbc_start_coeff2) sym_bc_start_coeff1 = Symbol('bc_start1') sym_bc_start_coeff2 = Symbol('bc_start2') bc_eqs = [Eq(sym_bc_start_coeff1, tbc_start_coeff1)] bc_eqs.append(Eq(sym_bc_start_coeff2, tbc_start_coeff2)) ``` $$\begin{cases} - 2 {L}_{0} & \text{for}\: yp_{0} < 9.9 \cdot 10^{29} \\1 & \text{otherwise} \end{cases}$$ $$\begin{cases} - {L}_{0} & \text{for}\: yp_{0} < 9.9 \cdot 10^{29} \\0 & \text{otherwise} \end{cases}$$ ```python # BC - first derivative specified at the end of the range ypn = Symbol('ypn') eqbc2=Eq(diff(si,t).subs(t,L[end-1]).subs(sln).subs(i,end-1),ypn) display(eqbc2) eqbc2b = divide_terms(expand(eqbc2),[E[end-1],E[end]],[y[end-1],y[end],ypn]) display(eqbc2b) eqbc2c = mult_eqn(eqbc2b, 6) display(eqbc2c) bc_firstd_end_coeff1 = get_coeff_for(eqbc2c.lhs, E[end-1],[E[end-1],E[end]]) display(bc_firstd_end_coeff1) bc_firstd_end_coeff2 = get_coeff_for(eqbc2c.lhs, E[end],[E[end-1],E[end]]) display(bc_firstd_end_coeff2) ``` $$\frac{\left({E}_{n - 1} - {E}_{n - 2}\right) {L}_{n - 2}}{2} + \frac{- \frac{\left({E}_{n - 1} + 2 {E}_{n - 2}\right) {L}_{n - 2}^{2}}{6} + {y}_{n - 1} - {y}_{n - 2}}{{L}_{n - 2}} + {E}_{n - 2} {L}_{n - 2} = ypn$$ $$\frac{{E}_{n - 1} {L}_{n - 2}}{3} + \frac{{E}_{n - 2} {L}_{n - 2}}{6} = ypn - \frac{{y}_{n - 1}}{{L}_{n - 2}} + \frac{{y}_{n - 2}}{{L}_{n - 2}}$$ $$2 {E}_{n - 1} {L}_{n - 2} + {E}_{n - 2} {L}_{n - 2} = 6 ypn - \frac{6 {y}_{n - 1}}{{L}_{n - 2}} + \frac{6 {y}_{n - 2}}{{L}_{n - 2}}$$ $${L}_{n - 2}$$ $$2 {L}_{n - 2}$$ ```python # Create the conditional expression for the end BC tbc_end_coeff1 = Piecewise((bc_firstd_end_coeff1, ypn < bc_cutoff),(bc_natural_end_coeff1, True)) display(tbc_end_coeff1) sym_bc_end_coeff1 = Symbol('bc_end1') bc_eqs.append(Eq(sym_bc_end_coeff1, tbc_end_coeff1)) tbc_end_coeff2 = Piecewise((bc_firstd_end_coeff2, ypn < bc_cutoff),(bc_natural_end_coeff2, True)) tbc_end_coeff2 display(tbc_end_coeff2) sym_bc_end_coeff2 = Symbol('bc_end2') bc_eqs.append(Eq(sym_bc_end_coeff2, tbc_end_coeff2)) ``` $$\begin{cases} {L}_{n - 2} & \text{for}\: ypn < 9.9 \cdot 10^{29} \\0 & \text{otherwise} \end{cases}$$ $$\begin{cases} 2 {L}_{n - 2} & \text{for}\: ypn < 9.9 \cdot 10^{29} \\1 & \text{otherwise} \end{cases}$$ ```python # conditional expressions for RHS for boundary conditions rhs_start = Piecewise((eqbc1c.rhs,yp0 < bc_cutoff),(bc_natural_start.rhs,True)) display(rhs_start) rhs_end = Piecewise((eqbc2c.rhs, ypn < bc_cutoff), (bc_natural_end.rhs, True)) display(rhs_end) sym_rhs_start = Symbol('rhs_start') sym_rhs_end = Symbol('rhs_end') bc_eqs.append(Eq(sym_rhs_start, rhs_start)) bc_eqs.append(Eq(sym_rhs_end, rhs_end)) bc_eqs ``` $$\begin{cases} 6 yp_{0} + \frac{6 {y}_{0}}{{L}_{0}} - \frac{6 {y}_{1}}{{L}_{0}} & \text{for}\: yp_{0} < 9.9 \cdot 10^{29} \\0 & \text{otherwise} \end{cases}$$ $$\begin{cases} 6 ypn - \frac{6 {y}_{n - 1}}{{L}_{n - 2}} + \frac{6 {y}_{n - 2}}{{L}_{n - 2}} & \text{for}\: ypn < 9.9 \cdot 10^{29} \\0 & \text{otherwise} \end{cases}$$ $$\left [ bc_{start1} = \begin{cases} - 2 {L}_{0} & \text{for}\: yp_{0} < 9.9 \cdot 10^{29} \\1 & \text{otherwise} \end{cases}, \quad bc_{start2} = \begin{cases} - {L}_{0} & \text{for}\: yp_{0} < 9.9 \cdot 10^{29} \\0 & \text{otherwise} \end{cases}, \quad bc_{end1} = \begin{cases} {L}_{n - 2} & \text{for}\: ypn < 9.9 \cdot 10^{29} \\0 & \text{otherwise} \end{cases}, \quad bc_{end2} = \begin{cases} 2 {L}_{n - 2} & \text{for}\: ypn < 9.9 \cdot 10^{29} \\1 & \text{otherwise} \end{cases}, \quad rhs_{start} = \begin{cases} 6 yp_{0} + \frac{6 {y}_{0}}{{L}_{0}} - \frac{6 {y}_{1}}{{L}_{0}} & \text{for}\: yp_{0} < 9.9 \cdot 10^{29} \\0 & \text{otherwise} \end{cases}, \quad rhs_{end} = \begin{cases} 6 ypn - \frac{6 {y}_{n - 1}}{{L}_{n - 2}} + \frac{6 {y}_{n - 2}}{{L}_{n - 2}} & \text{for}\: ypn < 9.9 \cdot 10^{29} \\0 & \text{otherwise} \end{cases}\right ]$$ ### Substitute cubic spline equations into tridiagonal solver ```python subslist = { a[start] : 0, a[i] : coeff1, a[end] : sym_bc_end_coeff1, b[start] : sym_bc_start_coeff1, b[i] : coeff2, b[end] : sym_bc_end_coeff2, c[start] : sym_bc_start_coeff2, c[i] : coeff3, c[end] : 0, d[start] : sym_rhs_start, d[i] : sp9.rhs, d[end] : sym_rhs_end, } # Replace knot spacing with differences bewteen knot locations subsL = { L[i] : x[i+1] - x[i], L[i+1] : x[i+2] - x[i+1], L[i-1] : x[i] - x[i-1], L[start] : x[start+1]-x[start], L[start+1] : x[start+2]-x[start+1], L[end-1] : x[end] - x[end-1], } subslist ``` $$\left \{ {a}_{0} : 0, \quad {a}_{i} : {L}_{i - 1}, \quad {a}_{n - 1} : bc_{end1}, \quad {b}_{0} : bc_{start1}, \quad {b}_{i} : 2 {L}_{i - 1} + 2 {L}_{i}, \quad {b}_{n - 1} : bc_{end2}, \quad {c}_{0} : bc_{start2}, \quad {c}_{i} : {L}_{i}, \quad {c}_{n - 1} : 0, \quad {d}_{0} : rhs_{start}, \quad {d}_{i} : \frac{6 {y}_{i + 1}}{{L}_{i}} - \frac{6 {y}_{i}}{{L}_{i}} + \frac{6 {y}_{i - 1}}{{L}_{i - 1}} - \frac{6 {y}_{i}}{{L}_{i - 1}}, \quad {d}_{n - 1} : rhs_{end}\right \}$$ ```python # Substitute into the tridiagonal solver display(teq1.subs(subslist)) teq2b = teq2.subs(subslist).subs(subsL) display(teq2b) teq3b = simplify(teq3.subs(subslist).subs(subsL)) display(teq3b) teq4b = teq4.subs(subslist).subs(subsL) display(teq4b) teq5b = Eq(teq5.lhs,teq5.rhs.subs(dp[end],teq3.rhs).subs(i,end).subs(subslist)) display(teq5b) display(teq6.subs(subslist)) ``` $${c'}_{0} = \frac{bc_{start2}}{bc_{start1}}$$ $${d'}_{0} = \frac{rhs_{start}}{bc_{start1}}$$ $${d'}_{i} = \frac{- \left({x}_{i + 1} - {x}_{i}\right) \left({x}_{i - 1} - {x}_{i}\right)^{2} {d'}_{i - 1} + 6 \left({x}_{i + 1} - {x}_{i}\right) \left({y}_{i - 1} - {y}_{i}\right) + 6 \left({x}_{i - 1} - {x}_{i}\right) \left(- {y}_{i + 1} + {y}_{i}\right)}{\left({x}_{i + 1} - {x}_{i}\right) \left({x}_{i - 1} - {x}_{i}\right) \left(- \left({x}_{i - 1} - {x}_{i}\right) {c'}_{i - 1} - 2 {x}_{i + 1} + 2 {x}_{i - 1}\right)}$$ $${c'}_{i} = \frac{{x}_{i + 1} - {x}_{i}}{- \left(- {x}_{i - 1} + {x}_{i}\right) {c'}_{i - 1} + 2 {x}_{i + 1} - 2 {x}_{i - 1}}$$ $${x}_{n - 1} = \frac{- bc_{end1} {d'}_{n - 2} + rhs_{end}}{- bc_{end1} {c'}_{n - 2} + bc_{end2}}$$ $${x}_{i} = - {c'}_{i} {x}_{i + 1} + {d'}_{i}$$ ```python # Extract sub-expressions subexpr, final_expr = cse([simplify(teq3b),simplify(teq4b)],symbols=numbered_symbols('z')) display(subexpr) display(final_expr) ``` $$\left [ \left ( z_{0}, \quad - {x}_{i}\right ), \quad \left ( z_{1}, \quad z_{0} + {x}_{i + 1}\right ), \quad \left ( z_{2}, \quad z_{0} + {x}_{i - 1}\right ), \quad \left ( z_{3}, \quad 2 {x}_{i + 1}\right ), \quad \left ( z_{4}, \quad 2 {x}_{i - 1}\right ), \quad \left ( z_{5}, \quad z_{2} {c'}_{i - 1}\right ), \quad \left ( z_{6}, \quad - {y}_{i}\right )\right ]$$ $$\left [ {d'}_{i} = \frac{z_{1} z_{2}^{2} {d'}_{i - 1} - 6 z_{1} \left(z_{6} + {y}_{i - 1}\right) + 6 z_{2} \left(z_{6} + {y}_{i + 1}\right)}{z_{1} z_{2} \left(z_{3} - z_{4} + z_{5}\right)}, \quad {c'}_{i} = \frac{- {x}_{i + 1} + {x}_{i}}{- z_{3} + z_{4} - z_{5}}\right ]$$ ```python # Substitute knot spacing into the boundary conditions bc_eqs2 = [eq.subs(subsL) for eq in bc_eqs] bc_eqs2 ``` $$\left [ bc_{start1} = \begin{cases} 2 {x}_{0} - 2 {x}_{1} & \text{for}\: yp_{0} < 9.9 \cdot 10^{29} \\1 & \text{otherwise} \end{cases}, \quad bc_{start2} = \begin{cases} {x}_{0} - {x}_{1} & \text{for}\: yp_{0} < 9.9 \cdot 10^{29} \\0 & \text{otherwise} \end{cases}, \quad bc_{end1} = \begin{cases} {x}_{n - 1} - {x}_{n - 2} & \text{for}\: ypn < 9.9 \cdot 10^{29} \\0 & \text{otherwise} \end{cases}, \quad bc_{end2} = \begin{cases} 2 {x}_{n - 1} - 2 {x}_{n - 2} & \text{for}\: ypn < 9.9 \cdot 10^{29} \\1 & \text{otherwise} \end{cases}, \quad rhs_{start} = \begin{cases} 6 yp_{0} + \frac{6 {y}_{0}}{- {x}_{0} + {x}_{1}} - \frac{6 {y}_{1}}{- {x}_{0} + {x}_{1}} & \text{for}\: yp_{0} < 9.9 \cdot 10^{29} \\0 & \text{otherwise} \end{cases}, \quad rhs_{end} = \begin{cases} 6 ypn - \frac{6 {y}_{n - 1}}{{x}_{n - 1} - {x}_{n - 2}} + \frac{6 {y}_{n - 2}}{{x}_{n - 1} - {x}_{n - 2}} & \text{for}\: ypn < 9.9 \cdot 10^{29} \\0 & \text{otherwise} \end{cases}\right ]$$ ```python # Use temporary storage for cp, and reuse output vector for dp # In the future there should be some dependency analysis to verify this is a legal transformation tmp = IndexedBase('u',shape=(n,)) y2 = IndexedBase('y2',shape=(n,)) storage_subs = {cp:y2, dp:tmp} #storage_subs = {} teq1c = teq1.subs(subslist).subs(storage_subs) display(teq1c) teq2c = teq2b.subs(subslist).subs(storage_subs) display(teq2c) teq3c = final_expr[0].subs(storage_subs) display(teq3c) teq4c = final_expr[1].subs(storage_subs) display(teq4c) teq5c = teq5b.subs(storage_subs).subs(x,y2) display(teq5c) teq6c = teq6.subs(storage_subs).subs(x,y2) display(teq6c) ``` $${y_{2}}_{0} = \frac{bc_{start2}}{bc_{start1}}$$ $${u}_{0} = \frac{rhs_{start}}{bc_{start1}}$$ $${u}_{i} = \frac{z_{1} z_{2}^{2} {u}_{i - 1} - 6 z_{1} \left(z_{6} + {y}_{i - 1}\right) + 6 z_{2} \left(z_{6} + {y}_{i + 1}\right)}{z_{1} z_{2} \left(z_{3} - z_{4} + z_{5}\right)}$$ $${y_{2}}_{i} = \frac{- {x}_{i + 1} + {x}_{i}}{- z_{3} + z_{4} - z_{5}}$$ $${y_{2}}_{n - 1} = \frac{- bc_{end1} {u}_{n - 2} + rhs_{end}}{- bc_{end1} {y_{2}}_{n - 2} + bc_{end2}}$$ $${y_{2}}_{i} = {u}_{i} - {y_{2}}_{i + 1} {y_{2}}_{i}$$ ```python # Now for some code generation #reload(codegen_more) #from codegen_more import * ``` ```python templateT = Type('T') ``` ```python # forward sweep fr = ARange(start+1,end,1) body = [] for e in subexpr: body.append(Variable(e[0],type=templateT).as_Declaration(value=e[1].subs(storage_subs))) body.append(convert_eq_to_assignment(teq3c)) body.append(convert_eq_to_assignment(teq4c)) loop1 = For(i,fr,body) ``` ```python # backward sweep br = ARangeClosedEnd(end-1,start,-1) loop2 = For(i,br,[convert_eq_to_assignment(teq6c)]) ``` ```python tmp_init = VariableWithInit("n",tmp,type=Type("std::vector<T>")).as_Declaration() bc_tmps = [] for e in bc_eqs2: bc_tmps.append(Variable(e.lhs, type=templateT).as_Declaration(value=e.rhs)) algo = CodeBlock(tmp_init, *bc_tmps, convert_eq_to_assignment(teq1c), convert_eq_to_assignment(teq2c), loop1, convert_eq_to_assignment(teq5c), loop2) ``` ```python # Generate the inner part of the algorithm to check it ACP = ACodePrinter() s = ACP.doprint(algo) print(s) ``` // Not supported in C++: // IndexedBase std::vector<T> u(n); T bc_start1 = ((yp0 < 9.9000000000000002e+29) ? ( 2*x[0] - 2*x[1] ) : ( 1 )); T bc_start2 = ((yp0 < 9.9000000000000002e+29) ? ( x[0] - x[1] ) : ( 0 )); T bc_end1 = ((ypn < 9.9000000000000002e+29) ? ( x[n - 1] - x[n - 2] ) : ( 0 )); T bc_end2 = ((ypn < 9.9000000000000002e+29) ? ( 2*x[n - 1] - 2*x[n - 2] ) : ( 1 )); T rhs_start = ((yp0 < 9.9000000000000002e+29) ? ( 6*yp0 + 6*y[0]/(-x[0] + x[1]) - 6*y[1]/(-x[0] + x[1]) ) : ( 0 )); T rhs_end = ((ypn < 9.9000000000000002e+29) ? ( 6*ypn - 6*y[n - 1]/(x[n - 1] - x[n - 2]) + 6*y[n - 2]/(x[n - 1] - x[n - 2]) ) : ( 0 )); y2[0] = bc_start2/bc_start1; u[0] = rhs_start/bc_start1; for (auto i = 1; i < n - 1; i += 1) { T z0 = -x[i]; T z1 = z0 + x[i + 1]; T z2 = z0 + x[i - 1]; T z3 = 2*x[i + 1]; T z4 = 2*x[i - 1]; T z5 = z2*y2[i - 1]; T z6 = -y[i]; u[i] = (z1*z2*z2*u[i - 1] - 6*z1*(z6 + y[i - 1]) + 6*z2*(z6 + y[i + 1]))/(z1*z2*(z3 - z4 + z5)); y2[i] = (-x[i + 1] + x[i])/(-z3 + z4 - z5); }; y2[n - 1] = (-bc_end1*u[n - 2] + rhs_end)/(-bc_end1*y2[n - 2] + bc_end2); for (auto i = n - 2; i >= 0; i += -1) { y2[i] = u[i] - y2[i + 1]*y2[i]; }; ```python # Set up to create a template function tx = Pointer(x,type=templateT) ty = Pointer(y,type=templateT) ty2 = Pointer(y2,type=templateT) yp0_var = Variable('yp0',type=templateT) ypn_var = Variable('ypn',type=templateT) tf = TemplateFunctionDefinition(void, "cubic_spline_solve",[tx,ty,n,yp0_var,ypn_var,ty2],[templateT],algo) ``` ```python ACP = ACodePrinter() s = ACP.doprint(tf) print(s) ``` // Not supported in C++: // IndexedBase // IndexedBase // IndexedBase // IndexedBase template<typename T> void cubic_spline_solve(T * x, T * y, int n, T yp0, T ypn, T * y2){ std::vector<T> u(n); T bc_start1 = ((yp0 < 9.9000000000000002e+29) ? ( 2*x[0] - 2*x[1] ) : ( 1 )); T bc_start2 = ((yp0 < 9.9000000000000002e+29) ? ( x[0] - x[1] ) : ( 0 )); T bc_end1 = ((ypn < 9.9000000000000002e+29) ? ( x[n - 1] - x[n - 2] ) : ( 0 )); T bc_end2 = ((ypn < 9.9000000000000002e+29) ? ( 2*x[n - 1] - 2*x[n - 2] ) : ( 1 )); T rhs_start = ((yp0 < 9.9000000000000002e+29) ? ( 6*yp0 + 6*y[0]/(-x[0] + x[1]) - 6*y[1]/(-x[0] + x[1]) ) : ( 0 )); T rhs_end = ((ypn < 9.9000000000000002e+29) ? ( 6*ypn - 6*y[n - 1]/(x[n - 1] - x[n - 2]) + 6*y[n - 2]/(x[n - 1] - x[n - 2]) ) : ( 0 )); y2[0] = bc_start2/bc_start1; u[0] = rhs_start/bc_start1; for (auto i = 1; i < n - 1; i += 1) { T z0 = -x[i]; T z1 = z0 + x[i + 1]; T z2 = z0 + x[i - 1]; T z3 = 2*x[i + 1]; T z4 = 2*x[i - 1]; T z5 = z2*y2[i - 1]; T z6 = -y[i]; u[i] = (z1*z2*z2*u[i - 1] - 6*z1*(z6 + y[i - 1]) + 6*z2*(z6 + y[i + 1]))/(z1*z2*(z3 - z4 + z5)); y2[i] = (-x[i + 1] + x[i])/(-z3 + z4 - z5); }; y2[n - 1] = (-bc_end1*u[n - 2] + rhs_end)/(-bc_end1*y2[n - 2] + bc_end2); for (auto i = n - 2; i >= 0; i += -1) { y2[i] = u[i] - y2[i + 1]*y2[i]; }; } ```python ``` ```python ```
7b01ff500c6cfa45f4fff37c44f8da2857c39ab1
58,317
ipynb
Jupyter Notebook
Wavefunctions/CubicSplineSolver.ipynb
QMCPACK/qmc_algorithms
015fd1973e94f98662149418adc6b06dcd78946d
[ "MIT" ]
3
2018-02-06T06:15:19.000Z
2019-11-26T23:54:53.000Z
Wavefunctions/CubicSplineSolver.ipynb
chrinide/qmc_algorithms
015fd1973e94f98662149418adc6b06dcd78946d
[ "MIT" ]
null
null
null
Wavefunctions/CubicSplineSolver.ipynb
chrinide/qmc_algorithms
015fd1973e94f98662149418adc6b06dcd78946d
[ "MIT" ]
4
2017-11-14T20:25:00.000Z
2022-02-28T06:02:01.000Z
31.403877
1,028
0.365434
true
9,653
Qwen/Qwen-72B
1. YES 2. YES
0.859664
0.817574
0.702839
__label__eng_Latn
0.199713
0.471262
```python from decodes.core import * from decodes.io.jupyter_out import JupyterOut import math out = JupyterOut.unit_square( ) ``` # Transformation Mathematics We are familiar with a set of operations in CAD designated by verbs, such as "Move”, “Mirror”, “Rotate”, and “Scale”, and that ***act upon a geometric object to produce the same kind of object, only transformed***. Operations such as these are termed ***transformations or transforms***. After an object has undergone a transformation, we can observe that certain properties of the object are altered while others are preserved. Mathematicians employ a number of terms (such as ***congruency, isometry, similarity, and affinity***) to classify transformations by the features they preserve and those they distort. Consider, for example, the axonometric projection transformation, which projects geometry onto a plane in such a way that parallel lines are mapped onto parallel lines, thereby maintaining parallelism. Mathematically speaking, we say that ***a transformation of a space onto itself is a rule which assigns to every point $P$ in the space another point $P^*$ in the space***. The simple reflection that was constructed by compass and straightedge is an example of a transformation of the plane (or any point on the plane) onto itself (in that all points end up somewhere else on the plane). Notice that, in the case of the mirror reflection, ***the kinds of things that come out after being reflected are the same kinds of things that go in***; namely, a reflected line is still a line with the same length, a reflected circle is still a circle with the same radius, and a reflected curve is still the same curve with all of the same geometric properties. There are other transformations that do not preserve geometric features in the same way. Consider the ***circle inversion transformation***, which can be expressed as the function below. \begin{align} T(x,y) = (\frac{R^2x}{x^2+y^2},\frac{R^2y}{x^2+y^2}) \end{align} The geometric properties that are preserved here may be more difficult to discern. Knowing that the graphic shows the inversion of points on a hexagonal grid, we can understand that while the linearity of lines are not preserved, the angle between two lines or curves is preserved. How and under what circumstances different classes of geometric features are preserved is an important and distinguishing property of transformations. Even though a transformation is formally defined as any function that takes a point and gives a point back in return, we will find it beneficial to narrow this definition to include only those transformations that may be represented by a particularly useful mathematical construct: ***the matrix***. A matrix is ***a structure for organizing sets of values in rows and columns, such that these values may be operated upon by a set of algebraic rules***. Matrix algebra underlies much of geometric computation. The expenditure of just a bit of effort in mastering the fundamentals of this potentially imposing mathematical construct will yield a wealth of insight in return. ## Matrix Fundamentals A brief account of the matrix will serve to ground our understanding of how transformations work in computer graphics in general, and will offer a basis for the implementation of transformations in the Decod.es library in particular. For this we will need a grasp of the basic notation for writing matrices, and a working understanding of how they are used to perform operations. In this section, we: * Detail the relevant notational conventions * Present the algebra of matrices * Demonstrate their basic operation on a simple example of transforming 2d vectors ### Matrix Notation A mathematical matrix is much like its namesake in code: a two-dimensional array that organizes values into regular rows and columns. An ***m x n matrix*** (read as “*m by n*”) and denoted throughout this chapter as $(m \times n)$, is an arrangement of elements into ***m rows*** and ***n columns***. Any matrix for which the number of rows and the number of columns are the same may be termed a square matrix. By convention, the notation for a generic element contained within a matrix is $c_{ij}$, with the subscript index $i$ indicating the containing row, and the index $j$ the containing column. Note that the conventional ordering of the indices of a matrix is the reverse of the `(x,y)` convention that we are accustomed to in describing horizontal and vertical positions. Also, positions are numbered starting at the top left, and the indexing starts with `(1,1)`, not with `(0,0)` as we have become accustomed to in code. \begin{bmatrix} c_{11} & c_{12} & c_{13} & c_{14} \\ c_{21} & c_{22} & c_{23} & c_{24} \\ c_{31} & c_{32} & c_{33} & c_{34} \end{bmatrix} ### Matrix Algebra With a grasp of the notation conventionally used to describe matrices, we are ready to review the rules by which they may be combined and manipulated. Three of the basic operations we are able to perform on matrices - addition, subtraction, and scalar multiplication - work exactly the same for matrices as they do for vectors, proceeding by operating on one set of matching components at a time. #### Matrix Addition Matrix addition and subtraction works ***component-wise***, matching components at the same indices of each matrix. This procedure requires that each matrix exhibits the same number of rows and columns. \begin{align} \begin{bmatrix} 2 & -1 \\ 3 & 0 \end{bmatrix} + \begin{bmatrix} -1 & 5 \\ 0 & 10 \end{bmatrix} = \begin{bmatrix} 1 & 4 \\ 3 & 10 \end{bmatrix} \end{align} #### Matrix-Scalar Multiplication Scalar multiplication matches the given scalar to each of the components of the matrix. \begin{align} 3 \begin{bmatrix} 1 & -1 \\ -2 & 1 \\ 0 & 2 \end{bmatrix} = \begin{bmatrix} 3 & -3 \\ -6 & 3 \\ 0 & 6 \end{bmatrix} \end{align} #### Matrix-Matrix Multiplication Matrices may be multiplied together to form another matrix, but the convention for doing so is more involved. Here, the components are formed by pairing rows of the first matrix with columns of the second and performing a “dot product” of the components. This convention imposes a rule on the shapes of the two matrices being multiplied: the number of columns in the first must match the number of rows of the second, such that a $(m \times p)$ matrix can only multiply a $(p \times n)$ matrix. The result of this multiplication is a $(m \times n)$ matrix that takes its number of rows from the first matrix, and its number of columns from the second. In summary: \begin{align} (m \times p)(p \times n) = (m \times n) \end{align} Each entry ***matches a row from the first matrix with a column from the second***, and is calculated by a dot product operation, as shown below. ### Matrices and Vectors Points and Vecs may be represented by matrices, such that a two-dimensional vector may be expressed as a $(1 \times 2)$ or, more often ***a $(2 \times 1)$ matrix***. Seen in this way, we can multiply a matrix by a vector only so long as the dimensions are compatible. A square matrix $M$, can then multiply a vector $\vec{x} = (x,y)$ in the following way: \begin{align} M\vec{x} = \begin{bmatrix} c_{11} & c_{12} \\ c_{21} & c_{22} \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = \begin{bmatrix} c_{11}x + c_{12}y \\ c_{21}x + c_{22}y \end{bmatrix} \end{align} A square matrix multiplied by a vector in $\mathbb{R}^2$ yields another vector in $\mathbb{R}^2$. We can legitimately say that ***$M$ maps one set of points onto a corresponding set of points***. This is the very definition of a transformation. It is no exaggeration to say that the implications of this are profound. Consider that we have demonstrated that ***a compact and versatile mathematical form is capable of describing a high-level operation***. So armed, we need not think of any geometric operation, such as the rotation of a set of objects about an axis, merely as a command in software. Instead, we now have ***a mathematical instrument that captures this action precisely, compactly, and in a format that is completely independent*** from any software platform. The ramifications of this discovery are indeed far-reaching, and extend well beyond the two-dimensional planar transformations captured by the square matrix demonstrated above. In summary. When a matrix $M$ multiplies a vector $\vec{x}$, it has the effect of transforming this vector into a new vector $M\vec{x}$. Substituting points for vectors, any $(2 \times 2)$ matrix can then be seen as a ***planar transformation*** that maps any point in the plane to another point in the plane. Similarly, a $(3 \times 3)$ matrix specifies a ***spatial transformation*** which maps a point from one location in space to another. We require two more insights before we are in good position for implementation. * We need a deeper understanding of the nature of ***a special class of transformations*** that represents the basic building blocks critical to many operations relevant to visual design. * To aggregate these basic elements into more complex operations requires ***a method for expressing transformations into coherent sequences***. #### Examples of Matrix-Vector Multiplication Before moving on, it will be worth our time to consider the specific cases outlined in a nearby table that demonstrate what happens to a generic vector when multiplied by a variety of fixed square matrices. These examples will help us to associate some familiar actions with matrices that produce them. ##### Scaling Matrix $ M = \begin{bmatrix} s & 0 \\ 0 & s \end{bmatrix} $ This matrix scales vectors by a uniform scaling factor as can be seen by multiplying the matrix by a vector, expanded out below. The vector is stretched for values of $s$ greater than one, and contracts for values less than one. For negative values of $s$, the transformed vector is both scaled and flipped across the origin. \begin{align} \begin{bmatrix} s & 0 \\ 0 & s \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = \begin{bmatrix} sx \\ sy \end{bmatrix} = s\begin{bmatrix} x \\ y \end{bmatrix} \end{align} ##### Rotation Matrix $ M = \begin{bmatrix} 0 & -1 \\ 1 & 0 \end{bmatrix} $ We can see what transformation this matrix represents by looking at how it acts on specific vectors. Multiplying this matrix by a vector rotates the vector by ninety degrees counterclockwise about the origin: * $(1,0)$ is transformed to $(0,1)$ * $(0,1)$ is transformed to $(-1,0)$ * $(- 1,0)$ is transformed to $(0, -1)$. \begin{align} \begin{bmatrix} 0 & -1 \\ 1 & 0 \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = \begin{bmatrix} (0x) + (-1y) \\ (1x) + (0y) \end{bmatrix} = \begin{bmatrix} -y \\ x \end{bmatrix} \end{align} ##### Mirror Matrix $ M = \begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix} $ This matrix transforms the vector $(x,y)$ to $(y,x)$ which is the vector mirrored across the line $y = x$. \begin{align} \begin{bmatrix} 0 & 1 \\ 1 & 0 \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = \begin{bmatrix} (0x) + (1y) \\ (1x) + (0y) \end{bmatrix} = \begin{bmatrix} y \\ x \end{bmatrix} \end{align} ##### Projection Matrix $ M = \begin{bmatrix} 1 & 0 \\ 0 & 0 \end{bmatrix} $ This matrix maps $(x,y)$ to $(x,0)$, its projection onto the x-axis. \begin{align} \begin{bmatrix} 1 & 0 \\ 0 & 0 \end{bmatrix} \begin{bmatrix} x \\ y \end{bmatrix} = \begin{bmatrix} (1x) + (0y) \\ (0x) + (0y) \end{bmatrix} = \begin{bmatrix} x \\ 0 \end{bmatrix} \end{align} ## Matrix Transformations The kind of transformations that can be described by matrices are very special, and just three categories of matrix transformations are prevalent in computer graphics: ***linear, affine, and projective transformations***. ***Linear transformations*** represent the most constrained category, and include elemental transforms such as rotation, scaling, shearing, and reflection. A discussion of these will comprise the bulk of this section. A closely related category are the ***affine transformations***. These are ***"almost" linear***, as they can be expressed as the combination of a linear transformation and a translation vector. While pairing a matrix with a vector can be useful, an even more compact representation of an affine transformation as a matrix can be achieved by ***elevating the dimension*** of the matrix. Finally, we have the ***projective transformations*** that include orthographic projection and perspectival projection. ### Linear Transformations To discuss the unique features of linear transformations, we will first establish the relationship between linear transformations and matrix transformations. To do so, we denote transformations that act on a vector by multiplication of a matrix as $T(\vec{x}) = M\vec{x}$. Matrices such as this share a number of properties in common for any choice of matrix $M$. Crucially, the following two properties hold true: * The transformation of the sum of any two vectors is equal to the sum of their individual transformations. In other words, $T(\vec{x} + \vec{y}) = T(\vec{x}) + T(\vec{y})$ for any vectors $\vec{x}$ and $\vec{y}$. * The transformation of the product of a scalar and a vector is equal to the product of the scalar and the transformation of the vector. In other words, $T(c\vec{x}) = cT(\vec{x})$ for any vector $\vec{x}$ and scalar $c$. Any transformation that satisfies these two properties is called a ***linear transformation***. Linearity yields a remarkable number of useful consequences. Among these, three are particularly relevant for our purposes: two that concern the preservation of geometric features, and one that allows us to predict the action of a transformation simply by examining the values held by particular components of it. * Linear transformations map straight lines to straight lines. * Linear transformations preserve parallelism * If we know how a linear transformation acts for ***each vector in a basis***, then we can predict how it will transform ***every point and vector in that space***. \begin{align} T(\vec{x}) = T(x,y) = xT(1,0) + yT(0,1) = xT(\vec{e_{1}}) + yT(\vec{e_{2}}) \end{align} This last property of linear transformations allows us to quickly read off the action of any given matrix, and enables us to write matrices with properties that we can easily control. Take, for example, the following matrix: An examination of the components here reveals how the standard basis vectors are transformed, and from this, we are able to extrapolate a pattern of behavior that can be applied more generally. \begin{align} \begin{bmatrix} 1 & 0 \\ 0 & 2 \end{bmatrix} \end{align} The basis vector $\vec{e_{1}} = (1,0)$ is unchanged by the transformation, but that $\vec{e_{2}} = (0,1)$ is stretched to twice its length. This is a scale 1d. \begin{align} \begin{bmatrix} 1 & 1 \\ 0 & 2 \end{bmatrix} \end{align} The vector $\vec{e_{1}} = (1,0)$ is again fixed, so the x-axis remains unchanged, but $\vec{e_{2}} = (0,1)$ is shifted to the line $y = 2x$. This is a shear. \begin{align} \begin{bmatrix} 1 & 0 \\ 0 & 1 \end{bmatrix} \end{align} This does precisely nothing. Mathematicians gave this one a compelling name: the identity transformation or $I$. \begin{align} T(\vec{x}) = xT(\vec{e_{1}}) + yT(\vec{e_{2}}) = \begin{bmatrix} T(\vec{e_{1}}) T(\vec{e_{2}}) \end{bmatrix} \vec{x} \end{align} Not only is every matrix transformation a linear one, but every linear transformation can be represented by a matrix. With this in mind, we can now assemble a library of useful linear transformations. #### Selected Linear Transformations in the Plane ##### Rotation $ \begin{bmatrix} cos\theta & -sin\theta \\ sin\theta & cos\theta \end{bmatrix} $ Building upon the earlier example representing a rotation by ninety degrees, the above matrix shows a transformation that rotates a vector by an arbitrary angle counter-clockwise about the origin. We’ve seen that all we need in order to construct this matrix is to understand how basis vectors are transformed. Working with the standard basis, we can show that rotating $\vec{e_{1}} = (1,0)$ by $\theta$ counterclockwise will result in the vector $(cos\theta, sin\theta)$. Similarly, $\vec{e_{2}} = (0,1)$ transforms to $(-sin\theta, cos\theta)$. Putting these transformed basis vectors as columns, we arrive at the nearby matrix. ##### Orthogonal Projection $ \begin{bmatrix} cos^2\theta & cos\theta \ sin\theta \\ cos\theta \ sin\theta & sin^2\theta \end{bmatrix} $ Given a line through the origin rotated at an angle $\theta$ counterclockwise from the horizontal, we may construct a matrix representing the transformation of the normal projection onto this line. The orthogonal projection of a point onto this line is equivalent to the nearest point on the line. To see how the standard basis vectors are transformed, we will make use of the formula for the projected vector derived using the dot product. Since a unit vector along the projection line is given by $\vec{u} = (cos\theta, sin\theta)$, the projected vector for $\vec{u_{1}}$ onto this line is given by \begin{align} (\vec{e_{1}} \bullet \vec{u}) \ \vec{u} = cos\theta \ (cos\theta, sin\theta) = (\ cos^2\theta, \ cos\theta sin\theta \ ) \end{align} Similarly, the projected vector for $\vec{e_{2}} = (0,1)$ is $( \ sin\theta, \ cos\theta sin^2\theta \ )$. ##### Mirror $ \begin{bmatrix} 2 \ cos^2\theta-1 & 2 \ cos\theta \ sin\theta \\ 2 \ cos\theta \ sin\theta & 2 \ sin^2\theta-1 \end{bmatrix} $ Given a line as constructed above, we may express a general mirror transformation across this line in terms of the projection vectors by simple vector subtraction, as given by \begin{align} \vec{p_{mirror}} = \vec{p_{near}} + ( \vec{p_{near}} - \vec{p}) = 2\vec{p_{near}} - \vec{p} \end{align} The reflection across this line of $\vec{e_{1}} = (1,0)$ is thus given by $2(cos^2 \theta, cos\theta sin\theta) - (1,0)$ and the mirror of $\vec{e_{1}} = (0,1)$ is given by $2(sin \theta, cos\theta sin^2\theta) - (0,1)$. From these, we arrive at the general mirror transformation above. ***What's missing?*** Examining what we have covered thus far, we may note the conspicuous absence of what is perhaps the most basic of all transformations: translation. Although basic, this transformation is actually not a linear transformation. Expressing translation as displacement by a fixed vector, $T(\vec{x}) = \vec{x} + \vec{b}$, we see that the first condition of linearity is violated by any nonzero translation vector $\vec{b}$. \begin{align} T(\vec{x} + \vec{y}) = \vec{x}+\vec{y}+\vec{b} \neq T(\vec{x}) + T(\vec{y}) \end{align} It appears the that ***translation is not able to be represented using a square matrix***. To account for a wider range of transformations that include translations using matrices requires elevating the size of the matrices employed. We'll get to that in a bit. ### The Algebra of Transformations in Sequence Some transformations are better described as a sequence of operations, broken down into an ordered list of more basic transformations. The order of operations at work here matters. One great advantage of the matrix form is that ***the cumulative effect of the application of a sequence of transformations is equivalent to the application of the ordered product of this sequence***. In other words, we can capture a series of transformations in a single matrix. Of critical importance here is the order in which this multiplication is done: Successive application of transformations represented by matrices translates to multiplying matrices in ***right-to-left order***. \begin{align} \begin{bmatrix} \frac{1}{\sqrt{2}} & \frac{-1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \end{bmatrix} \begin{bmatrix} -1 & 0 \\ 0 & 1 \end{bmatrix} = \begin{bmatrix} \frac{-1}{\sqrt{2}} & \frac{-1}{\sqrt{2}} \\ \frac{-1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \end{bmatrix} \end{align} \begin{align} \begin{bmatrix} -1 & 0 \\ 0 & 1 \end{bmatrix} \begin{bmatrix} \frac{1}{\sqrt{2}} & \frac{-1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \end{bmatrix} = \begin{bmatrix} \frac{-1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \\ \frac{1}{\sqrt{2}} & \frac{1}{\sqrt{2}} \end{bmatrix} \end{align} ## From Math to Code The matrices used to express transformations in three-dimensional space are not $(3 \times 3)$, as we would expect from the discussion so far. Rather, they are $(4 \times 4)$. In deconstructing the rationale behind this, we address the question of how to represent the translation transformation. The easiest way to include translation into the mix of linear transformations is simply to combine a linear transformation with a translation vector: $T(\vec{x}) = Mx + \vec{b}$. In fact, this broader set of transformations make up the class of ***affine transformations***. Every linear transformation is affine but not the other way around. Tacking a vector on a matrix to deal with affine transformations is fantastic, but it ruins the purity of the matrix format. This is no good when considering how to move from math to code. There is an alternative. We can employ a system of coordinates called ***homogeneous coordinates***. By employing these, it is possible to use a $(4 \times 4)$ matrix to describe not only affine transformations in a three-dimensional space, but also many other useful transforms. ### The Elevated Matrix The dominant technique in computer graphics is to elevate the square matrix to have an added dimension on each side. Therefore, $(3 \times 3)$ matrices are used for transformations in two dimensions and $(4 \times 4)$ are used for transformations in three dimensions. This unified representation both accounts for ***translation***, and accommodates the larger class of ***projective transformations*** which includes perspective projection. Since matrix multiplication only works if the two matrices involved have compatible shapes, this technique also require vectors and points that exhibit a modified structure. To be compatible with elevated matrices, our points and vectors must be granted an extra coordinate. Points in homogeneous coordinates are interchangeable with Cartesian points so long as $w = 1$, while vectors in homogeneous coordinates maintain a $w = 0$. We can learn alot by simply familiarizing ourselves with the relationship between certain patterns of component values in a $(4 \times 4)$ matrix and the spatial transformations that result. First, the long awaited ***translation transformation***. \begin{align} \begin{bmatrix} 1 & 0 & 0 & b_{x} \\ 0 & 1 & 0 & b_{y} \\ 0 & 0 & 1 & b_{z} \\ 0 & 0 & 0 & 1 \\ \end{bmatrix} \begin{bmatrix} x \\ y \\ z \\ 1 \end{bmatrix} = \begin{bmatrix} x + b_{x} \\ y + b_{y} \\ z + b_{z} \\ 1 \end{bmatrix} \end{align} This translation matrix applied to points moves them, but applied to a vector in homogeneous coordinates $(x,y,z,0)$, leaves the vector unchanged. ```python ```
3c9cc74527c223690a3d4d7509cc2912e12c259c
35,016
ipynb
Jupyter Notebook
107 - Transformations and Intersections/242 - Transformation Mathematics.ipynb
ksteinfe/decodes_ipynb
2e4bb6b398472fc61ef8b88dad7babbdeb2a5754
[ "MIT" ]
1
2018-05-15T14:31:23.000Z
2018-05-15T14:31:23.000Z
107 - Transformations and Intersections/242 - Transformation Mathematics.ipynb
ksteinfe/decodes_ipynb
2e4bb6b398472fc61ef8b88dad7babbdeb2a5754
[ "MIT" ]
null
null
null
107 - Transformations and Intersections/242 - Transformation Mathematics.ipynb
ksteinfe/decodes_ipynb
2e4bb6b398472fc61ef8b88dad7babbdeb2a5754
[ "MIT" ]
2
2020-05-19T05:40:18.000Z
2020-06-28T02:18:08.000Z
41.439053
467
0.617061
true
5,839
Qwen/Qwen-72B
1. YES 2. YES
0.695958
0.847968
0.59015
__label__eng_Latn
0.998084
0.209447
# Announcements - No Problem Set this week, Problem Set 4 will be posted on 9/28. - Stay on at the end of lecture if you want to ask questions about Problem Set 3. <style> @import url(https://www.numfys.net/static/css/nbstyle.css); </style> <a href="https://www.numfys.net"></a> # Ordinary Differential Equations - higher order methods <section class="post-meta"> Based on notes and notebooks by Niels Henrik Aase, Thorvald Ballestad, Vasilis Paschalidis and Jon Andreas Støvneng </section> ## Algorithms for initial value problem ODEs Assume we have a first-order differential equation which can be expressed in the form $$ \frac{dy}{dt} = g(y,t) $$ We will solve this on constant-interval mesh of the independent variable $t$ defined by $$ t_n = t_0 + n h $$ ### Forward-Euler method In Lecture 10 we derived Euler's method, which simply solves the first-order forward difference approximation to $dy/dt$ $$ \frac{y_{i+1}-y_i}{h} = g(y_i,t_i)$$ as $$ y_{i+1} = y_i + h g(y_i,t_i) \label{Euler_fwd}\tag{3}$$ ```python # Importing the necessary libraries import numpy as np # NumPy is used to generate arrays and to perform some mathematical operations import matplotlib.pyplot as plt # Used for plotting results ``` ```python def forwardEuler_step(t, y, h, g, *P): """ Implements a single step of the forward-Euler finite-difference scheme Parameters: t: time t y: Numerical approximation of y at time t h: Step size g: RHS of our ODE (RHS = Right hand side). Can be any function with signature g(t,y,*P). *P: tuple of parameters, arguments to g Returns: next_y: Numerical approximation of y at time t+h """ next_y = y + h*g(t, y, *P) return next_y ``` We now need some sort of framework which will take this function and do the integration for us. Let's rewrite `full_Euler` from Lecture 10 to be more general: ```python def odeSolve(t0, y0, tmax, h, g, method, *P): """ A full numerical aproximation of an ODE in a set time interval. Performs consecutive steps of `method` with step size h from start time until the end time. Also takes into account the initial values of the ODE Parameters: t0: start time y0 : Initial condition for y at t = t0 tmax: The end of the interval where the `method` is integrated, t_N h: Step size g: RHS of our ODE (RHS = Right hand side). Can be any function with signature g(t,y,*P). *P: tuple of parameters, arguments to g Returns: t_list: Evenly spaced discrete list of time with spacing h. Starting time = start_t, and end time = end_t y_list: Numerical approximation of y at times t_list """ # make the t-mesh; guarantees we stop precisely at tmax t_list = np.arange(t0,tmax+h,h) # allocate space for the solution y_list = np.zeros_like(t_list) # set the initial condition y_list[0] = y0 # find out the size of the t-mesh, and then integrate forward one meshpoint per iteration of the loop n, = t_list.shape for i in range(0,n-1): y_list[i+1] = method(t_list[i], y_list[i], h, g, *P) # return the solution return t_list,y_list ``` Armed with this machinery, let's set up another simple problem and try it out. Last time, we looked at exponential growth, let's solve exponential decay this time: $$ \frac{dy}{dt} = - c y, \quad y[0] = 1 $$ First, we provide a function to implement the RHS: ```python def expRHS(t, y, c): """ Implements the RHS (y'(x)) of the DE """ return -c*y ``` Now we set up the problem to compute and plot the result, along with a plot of the magnitude of the fractional error ### Runge-Kutta Schemes The idea of the Runge-Kutta schemes is to take advantage of derivative information at the times between $t_i$ and $t_{i+1}$ to increase the order of accuracy. For example, in the midpoint method, the derivative at the initial time is used to approximate the derivative at the midpoint of the interval, $f(y_i+\frac{1}{2}hf(y_i,t_i), t_i+\frac{1}{2}h)$. The derivative at the midpoint is then used to advance the solution to the next step. The method can be written in two stages $k_i$, $$ \begin{aligned} \begin{array}{l} k_1 = h f(y_i,t_i)\\ k_2 = h f(y_i+\frac{1}{2}k_1, t_n+\frac{1}{2}h)\\ y_{i+1} = y_i + k_2 \end{array} \end{aligned}\label{RK2}\tag{4} $$ The midpoint method is known as a __2nd-order Runge-Kutta__ formula. In general, an explicit 2-stage Runge-Kutta method can be written as, $$ \begin{array}{l} k_1 = h f(y_n,t_n)\\ k_2 = h f(y_n+b_{21}k_1, t_n+a_2h)\ \\ y_{n+1} = y_n + c_1k_1 +c_2k_2 \label{explicitrk2}\tag{5}\end{array} $$ The scheme is said to be *explicit* since a given stage does not depend *implicitly* on itself, as in the backward Euler method , or on a later stage. Other explicit second-order schemes can be derived by comparing Eq.(\ref{explicitrk2}) to other second-order expansions and matching terms to determine the coefficients $a_2$, $b_{21}$, $c_1$ and $c_2$. ### Explicit Fourth-Order Runge-Kutta Method Explicit Runge-Kutta methods are popular as each stage can be calculated with one function evaluation. In contrast, implicit Runge-Kutta methods usually involves solving a non-linear system of equations in order to evaluate the stages. As a result, explicit schemes are much less expensive to implement than implicit schemes. The higher-order Runge-Kutta methods can be derived by in manner similar to the midpoint formula. An s-stage method is compared to a Taylor method and the terms are matched up to the desired order. As it happens to be, <strong>The Fourth Order Runge-Kutta Method</strong> uses three such test-points and is the most widely used Runge-Kutta Method. You might ask why we don't use five, ten or even more test-points, and the answer is quite simple: It is not computationally free to calculate all these test-points, and the gain in accuracy rapidly decreases beyond the fourth order of the method. That is, if high precision is of such importance that you would require a tenth-order Runge-Kutta, then you're better off reducing the step size $h$, than increasing the order of the method. Also, there exists other more sophisticated methods which can be both faster and more accurate for equivalent choices of $h$, but obviously, may be a lot more complicated to implement. See for instance <i>Richardson Extrapolation</i>, <i>the Bulirsch-Stoer method</i>, <i>Multistep methods, Multivalue methods</i> and <i>Predictor-Corrector methods</i>. The classic fourth-order Runge-Kutta formula is: $$ \begin{array}{l} k_1 = h f(y_n,t_n)\\ k_2 = h f(y_n+\frac{k_1}{2}, t_n+\frac{h}{2})\\ k_3 = h f(y_n+\frac{k_2}{2}, t_n+\frac{h}{2})\\ k_4 = h f(y_n+k_3, t_n+h)\\ y_{n+1} = y_n + \frac{k_1}{6}+ \frac{k_2}{3}+ \frac{k_3}{3} + \frac{k_4}{6} \label{RK4}\tag{6}\end{array} $$ ```python def RK2_step(t, y, h, g, *P): """ Implements a single step of the second-order, explicit midpoint method """ thalf = t + 0.5*h k1 = h * g(t, y, *P) k2 = h * g(thalf, y + 0.5*k1, *P) return y +k2 ``` ```python def RK4_step(t, y, h, g, *P): """ Implements a single step of a fourth-order, explicit Runge-Kutta scheme """ thalf = t + 0.5*h k1 = h * g(t, y, *P) k2 = h * g(thalf, y + 0.5*k1, *P) k3 = h * g(thalf, y + 0.5*k2, *P) k4 = h * g(t + h, y + k3, *P) return y + (k1 + 2*k2 + 2*k3 + k4)/6 ``` ```python # set up problem c = 1.0 h = 0.5 t0 = 0.0 y0 = 1.0 tmax = 5.0 # call the solver for RK2 t, y = odeSolve(t0, y0, tmax, h, expRHS, RK2_step, c) # plot the result fig,ax = plt.subplots(1,2) ans = np.exp(-c*t) ax[0].plot(t,ans,'r') ax[0].set_xlabel('t') ax[0].set_ylabel('y') ax[0].plot(t,y,'o','RK2') err_RK2 = np.abs((ans-y)/ans) # call the solver for Euler t, y = odeSolve(t0, y0, tmax, h, expRHS, forwardEuler_step, c) ax[0].plot(t,y,'o','Euler') err = np.abs((ans-y)/ans) # call the solver for RK2 t, y4 = odeSolve(t0, y0, tmax, h, expRHS, RK4_step, c) ax[0].plot(t,y4,'o','RK4') err_RK4 = np.abs((ans-y4)/ans) # along with the errors err_RK2 = np.abs((ans-y)/ans) ax[1].plot(t, err_RK2, 'o',label = "RK2") ax[1].plot(t, err_RK4, 'o',label = "RK4") ax[1].plot(t, err, 'o',label = "Euler") ax[1].set_xlabel('t') ax[1].set_ylabel('fractional error') ax[1].legend() # now also overplot the error we calculated for forward-Euler # this gives better spacing between axes plt.tight_layout() plt.show() ``` ### Systems of First-Order ODEs Next, we turn to systems of ODE's. We'll take as our example the Lotke-Volterra equations, a simple model of population dynamics in an ecosystem (with many other uses as well). Imagine a population of rabbits and of foxes on a small island. The rabbits eat a plentiful supply of grass and would breed like, well, rabbits, with their population increasing exponentially with time in the absence of preditors. The foxes eat the rabbits, and would die out exponentially in time with no food supply. The rate at which foxes eat rabbits depends upon the product of the fox and rabbit populations. The equations for the population of the rabbits $R$ and foxes $F$ in this simple model is then \begin{eqnarray*} \frac{dR}{dt} &= \alpha R - \beta R F \\ \frac{dF}{dt} &= \delta R F - \gamma F \end{eqnarray*} Without the cross terms in $RF$, these are just two decay equations of the form we have used as an example above. A random set of parameters (I am not a biologist!) might be that a rabbit lives four years, so $\alpha=1/4$ and a fox lives 10 years, so $\gamma=1/10$. Let's pick the other parameters as $\beta = 1$ and $\delta = 1/4$. We can express the unknown populations as a vector of length two: $y = (R, F)$. The rate of change of populations then can also be expressed as a vector $dy/dt = (dR/dt, DF/dt)$. With such a definition, we can write the RHS function of our system as ```python def lvRHS(t, y, *P): # Lotke-Volterra system RHS # unpack the parameters from the array P alpha, beta, gamma, delta = P # make temporary variables with rabbit and fox populations R = y[0] F = y[1] # LV system dRdt = alpha * R - beta * R * F dFdt = delta * R * F - gamma * F # return an array of derivatives with same order as input vector return np.array([ dRdt, dFdt ]) ``` We now have to generalize our odeSolve function to allow more than one equation ```python def odeSolve(t0, y0, tmax, h, RHS, method, *P): """ ODE driver with constant step-size, allowing systems of ODE's """ # make array of times and find length of array t = np.arange(t0,tmax+h,h) ntimes, = t.shape # find out if we are solving a scalar ODE or a system of ODEs, and allocate space accordingly if type(y0) in [int, float]: # check if primitive type -- means only one eqn neqn = 1 y = np.zeros( ntimes ) else: # otherwise assume a numpy array -- a system of more than one eqn neqn, = y0.shape y = np.zeros( (ntimes, neqn) ) # set first element of solution to initial conditions (possibly a vector) y[0] = y0 # march on... for i in range(0,ntimes-1): y[i+1] = method(t[i], y[i], h, RHS, *P) return t,y ``` Now we can solve our system of two coupled ODEs. Note that the solution is now a vector of 2D vectors... the first index is the solution time, the second the variable: ```python alpha = 1.0 beta = 0.025 gamma = 0.4 delta = 0.01 h = 0.2 t0 = 0.0 y0 = np.array([ 30, 10 ]) tmax = 50 # call the solver t, y = odeSolve(t0, y0, tmax, h, lvRHS, RK4_step, alpha, beta, gamma, delta) fig,ax = plt.subplots() ax.plot(t,y[:,0],'b', label='prey') ax.plot(t,y[:,1],'r', label='preditor') ax.set_xlabel('time') ax.set_ylabel('population') ax.legend() plt.tight_layout() plt.show() ``` ### Higher Order Derivatives and Sets of 1st order ODEs The trick to solving ODEs with higher derivatives is turning them into systems of first-order ODEs. As a simple example, consider the second-order differential equation describing the van der Pol oscillator $$ \frac{d^2 x}{dt^2} - a (1-x^2) \frac{dx}{dt} + x = 0 $$ We turn this into a pair of first-order ODEs by defining an auxiliary function $v(t) = dx/dt$ and writing the system as \begin{align} \begin{split} \frac{dv}{dt} &= a (1-x^2) v - x\\ \frac{dx}{dt} &= v \end{split} \end{align} Note that there are only functions (and the independent variable) on the RHS; all "differentials" are on the LHS. Now that we have a system of first-order equations ,we can proceed as above. A function describing the RHS of this system is ```python def vdpRHS(t, y, a): # we store our function as the array [x, x'] return np.array([ y[1], # dx/dt = v a*(1-y[0]**2)*y[1] - y[0] # dv/dt = a*(1-x**2)*v - x ]) ``` ```python a = 15 # parameter h = 0.01 t0 = 0.0 y0 = np.array([ 0, 1]) tmax = 50 # call the solver t, y = odeSolve(t0, y0, tmax, h, vdpRHS, RK4_step, a) fig,ax = plt.subplots() ax.plot(t,y[:,0],'b', label='x') ax.plot(t,y[:,1],'r--', label='v') ax.set_xlabel('time') ax.legend() ax.set_title(f"van der Pol Oscillator for a={a}") plt.tight_layout() plt.show() ``` A somewhat more complex example is the Lane-Emden equation, which is really just Poisson's equation in spherical symmetry for the graviational potential of a self-gravitating fluid whose pressure is related to its density as $P\propto\rho^\gamma$. Such a system is called a _polytrope_, and is often used in astrophysics as a simple model for the structure of system such as a a star in which outward pressure and inward gravity are in equilibrium. Let $\xi$ be the dimensionless radius of the system, and let $\theta$ be related to the density as $\rho = \rho_c \theta^n$, where $\rho_c$ is the density at the origin and $n = 1/(\gamma-1)$. We then have the dimensionless second-order differential equation $$ \frac{1}{\xi^2}\frac{d}{d\xi}\left(\xi^2\frac{d\theta}{d\xi}\right) + \theta^n = 0 $$ Note that the first term is just the divergence $\nabla\cdot\theta$ in spherical symmetry. If we expand out the first term, we have $$ \frac{d^2\theta}{d\xi^2} + \frac{2}{\xi}\frac{d\theta}{d\xi} + \theta^n = 0 $$ Defining an auxiliary function $v(\xi) = d\theta/d\xi$, we can then convert this into a system of two first-order ODEs: \begin{align} \begin{split} \frac{dv}{d\xi} &= -\frac{2}{\xi} v - \theta^n \\ \frac{d\theta}{d\xi} &= v \end{split} \end{align} Again, we have "derivatives" only on the LHS and no derivatives on the RHS of our system. Looking at this expression, one can see right away that at the origin $\xi=0$ we will have a numerical problem; we are dividing by zero. Analytically, this is not a problem, since $v/\xi\rightarrow0$ as $\xi\rightarrow0$, but here we need to address this numerically. The first approach is to take care of the problem in our RHS function: ```python def leRHS(x, y, n): dthetadx = y[1] if x==0: dvdx = -y[0]**n else: dvdx = -2/x*y[1] - y[0]**n return np.array([ dthetadx, dvdx ]) ``` This is somewhat clunky, however, and you would first have to convince yourself that in fact $v(\xi)\rightarrow0$ faster than $\xi$ (don't just take my word for it!). Instead, we could use a more direct RHS function ```python def leRHS(x, y, n): dthetadx = y[1] dvdx = -2/x*y[1] - y[0]**n return np.array([ dthetadx, dvdx ]) ``` and expand the solution in a Taylor series about the origin to get a starting value for our numerical integration at a small distance away from the origin. To do this, write $$\theta(\xi) = a_0 + a_1 \xi + a_2 \xi^2 + \dots$$ The first thing to notice is that, by symmetry, only even powers of $\xi$ will appear in the solution. Thus we will have $$ \theta(\xi) = a_0 + a_2 \xi^2 + a_4 \xi^4 + \dots$$ By the boundary condition $\theta(0) = 1$, we have immediately that $a_0 = 1$. Next, substitute $\theta(\xi) = 1 + a_2 \xi^2 + a_4 \xi ^4 + O(\xi^6)$ into the Lane-Emden equation. $\theta$ and its first two derivatives are \begin{align} \begin{split} \theta(\xi) &= 1 + a_2 \xi^2 + a_4 \xi^4 + O(\xi^6)\\ \theta'(\xi) &= 2 a_2 \xi + 4 a_4 \xi^3 + O(\xi^5) \\ \theta''(\xi) &= 2 a_2 + 12 a_4 \xi^2 + O(\xi^4) \end{split} \end{align} Putting these into the Lane-Emden equation, we have \begin{align} \begin{split} 2 a_2 + 12 a_4 \xi^2 + O(\xi^4) + \frac{2}{\xi} (2 a_2 x + 4 a_4 \xi^3 + O(\xi^5)) &= -\theta^n \\ 6 a_2 + 20 a_4 \xi^2 + O(\xi^4) &= -\theta^n \end{split} \end{align} A boundary condition $\theta(0)=1$, and thus we have $a_2 = -1/6$. Away from zero, then, we have \begin{align} \begin{split} -1 + 20 a_4 \xi^2 + O(\xi^4) &= -\left(1 - 1/6 \xi^2 + a_4 \xi^4 + O(\xi^6)\right)^n \end{split} \end{align} The term on the RHS is $ 1 - n \xi^2/6 + O(\xi^4)$, and so we must have $a_4 = n/120$. Thus, the series expansion of the solution around the origin is $$ \theta(\xi) = 1 - \frac{1}{6}\xi^2 + \frac{n}{120} \xi^4 + \dots $$ We can now use this expansion to take a first step slightly away from the origin before beginning our numerical integration, thus avoiding the divide by zero. Note that this series solution near the origin is $O(h^5)$ and so is a good match for RK4 if we take the same (or smaller) step-size. ```python n = 3 xi0 = 0.01 # starting value of xi for our numerical integration theta0 = 1 - xi0**2/6 + n*xi0**4/120 # Taylor series solution to the DE near zero derived above theta0p = -xi0/3 + n*xi0**3/30 y0 = np.array([ theta0, theta0p]) # set IC's for numerical integration print(f"IC at {xi0:10.5e}: {y0[0]:10.5e}, {y0[1]:10.5e}") h = 0.1 tmax = 8 # call the solver t, y = odeSolve(xi0, y0, tmax, h, leRHS, RK4_step, n) fig,ax = plt.subplots() ax.plot(t,y[:,0],'b', label=r'$\theta(\xi)$') ax.plot(t,y[:,1],'r--', label=r'$\frac{d\theta}{d\xi}$') ax.plot([0,tmax],[0,0],'k') ax.set_xlabel(r'$\xi$') ax.set_title(f"Lane Emden Equation for n={n}") ax.legend() plt.tight_layout() plt.show() ``` For values of $n\le5$, the solutions of the Lane Emden equation (the so-called Lane-Emden functions of index $n$) decrease to zero at finite $\xi$. Since this is the radius at which the density goes to zero, we can interpret it as the surface of the self-gravitating body (for example, the radius of the star). Knowing this value $\xi_1$ is thus interesting... Let us see how to determine it numerically. Cleary, we are looking for the solution to $\theta(\xi_1)=0$; this is just root-finding, which we already know how to do. Instead of using some closed-form function, however, the value of the function $\theta(\xi)$ must in this case be determined numerically. But we have just figured out how to do this! Let's use the bisection method for our root-finding algorithm; here is a quick version (no error checking!) ```python def bisection(func, low, high, eps, *P): flow = func(low, *P) fhigh = func(high, *P) mid = 0.5*(low+high) fmid = func(mid,*P) while (high-low)> eps: if fmid*flow < 0: high = mid fhigh = fmid else: low = mid flow = mid mid = 0.5*(low+high) fmid = func(mid,*P) return low ``` Now let us make a function which returns $\theta(\xi)$, the solution to the Lane-Emden equation at $\xi$ ```python def theta(xi, n): h = 1e-4 xi0 = 1e-4 theta0 = 1 - xi0**2/6 + n*xi0**4/120 theta0p = -xi0/3 + n*xi0**3/30 y0 = np.array([ theta0, theta0p]) t, y = odeSolve(xi0, y0, xi, h, leRHS, RK4_step, n) return y[-1,0] ``` Using these, we can compute the surface radius of the polytrope ```python n = 3 xi1 = bisection(theta, 6, 8, 1e-5, n) print(f"xi_1 = {xi1:7.5f}") ``` A more careful treatment gives a value $\xi_1 = 6.89685...$, so we are doing pretty well... ```python ```
30c00abbaaa3111abafe96512375232710a15b33
28,444
ipynb
Jupyter Notebook
Lectures/Lecture 12/Lecture12_ODE_part3.ipynb
astroarshn2000/PHYS305S20
18f4ebf0a51ba62fba34672cf76bd119d1db6f1e
[ "MIT" ]
3
2020-09-10T06:45:46.000Z
2020-10-20T13:50:11.000Z
Lectures/Lecture 12/Lecture12_ODE_part3.ipynb
astroarshn2000/PHYS305S20
18f4ebf0a51ba62fba34672cf76bd119d1db6f1e
[ "MIT" ]
null
null
null
Lectures/Lecture 12/Lecture12_ODE_part3.ipynb
astroarshn2000/PHYS305S20
18f4ebf0a51ba62fba34672cf76bd119d1db6f1e
[ "MIT" ]
null
null
null
36.84456
598
0.544825
true
6,292
Qwen/Qwen-72B
1. YES 2. YES
0.880797
0.91848
0.808995
__label__eng_Latn
0.987972
0.717899
# definition 数值定义. 对于 N-bit two's complement number system, 最高位 N-th bit 为符号位, 0 为正, 1 为负. 对于任意一个非负整数, 它的相反数为 its complement with respect to $2^N$. # properties - 一个数字的 two's complement 可以通过: 1. take its ones' complement and add one. 因为: the sum of a number and its ones' complement is -0, i.e. ‘1’ bits, or $2^N-1$; and by definition, the sum of a number and its two's complement is $2^N$. 2. 通过定义中的 unsigned binary arithmetic 计算得出. - The value of A N-bit binary number in two's complement numercal system can be computed by $$w = -a_{N-1} 2^{N-1} + \sum_{i=0}^{N-2} a_i 2^i$$. 推导: 对于互为相反数的 $A$ 和 $B$, 已知: $$ \begin{align} A + B &= 0 \\ A &= \sim B + 1 \end{align} $$ 第二式为 two's complement 和 ones' complement 的关系. 根据第二式得到 $$ A=1+\sum_{i=0}^{N-1}(1-b_i)2^i $$ 对于 N-bit number system, $A+B=0$ 意味着 $$(A+B) \operatorname{mod} 2^N = 0$$ 满足上式的 $B$ 有两种设计方式: $$ \begin{align} B &= b_{N-1}2^{N-1} + \sum_{i=0}^{N-2}b_i 2^i \\ B &= -b_{N-1}2^{N-1} + \sum_{i=0}^{N-2}b_i 2^i \end{align} $$ 分别对应于 unsigned number 和 signed number 的数值公式. - most negative number, `INT_MIN`. 它没有可以在系统内表达的相反数. 因为正负数范围的不对称性. 根据 two's complement 的定义计算 `INT_MIN` 得到的是自身, 这显然是不对的. - 加减法. 普通的二进制加减法运算即可, 没有特殊处理. - 加减法的溢出检测. an XOR operation on leftmost two carry/borrow bits can quickly determine if an overflow condition exists. ```python ```
57e58ee67b325cd5a78841b53ba007ba4ce08912
2,461
ipynb
Jupyter Notebook
math/arithmetic/binary-arithmetic/two-s-complement.ipynb
Naitreey/notes-and-knowledge
48603b2ad11c16d9430eb0293d845364ed40321c
[ "BSD-3-Clause" ]
5
2018-05-16T06:06:45.000Z
2021-05-12T08:46:18.000Z
math/arithmetic/binary-arithmetic/two-s-complement.ipynb
Naitreey/notes-and-knowledge
48603b2ad11c16d9430eb0293d845364ed40321c
[ "BSD-3-Clause" ]
2
2018-04-06T01:46:22.000Z
2019-02-13T03:11:33.000Z
math/arithmetic/binary-arithmetic/two-s-complement.ipynb
Naitreey/notes-and-knowledge
48603b2ad11c16d9430eb0293d845364ed40321c
[ "BSD-3-Clause" ]
2
2019-04-11T11:02:32.000Z
2020-06-27T11:59:09.000Z
30.7625
102
0.502641
true
675
Qwen/Qwen-72B
1. YES 2. YES
0.872347
0.875787
0.76399
__label__eng_Latn
0.872233
0.613338
```python from sympy import * from sympy.abc import m,M,l,b,c,g,t from sympy.physics.mechanics import dynamicsymbols, init_vprinting th = dynamicsymbols('theta') x = dynamicsymbols('x') dth = diff(th) dx = diff(x) ddth = diff(dth) ddx = diff(dx) init_vprinting() ``` ```python ``` ```python ddth = (-(1/2)*m*l cos(th)ddth - b*dx +(1/2)*m*l*sin(th)*dth*dx)/((m/12)(3l+l^2)) ddx = (-(1/2)*m*l cos(th)ddth - b*dx +(1/2)*m*l*sin(th)*dth^2)/(M+m) ```
de761e7fe343e53c15b1cbb441c4f622da1a09df
1,294
ipynb
Jupyter Notebook
notebook.ipynb
dnlrbns/pendcart
696c5d2c5fc7b787f3ab074e3ec3949a94dfc5ed
[ "MIT" ]
null
null
null
notebook.ipynb
dnlrbns/pendcart
696c5d2c5fc7b787f3ab074e3ec3949a94dfc5ed
[ "MIT" ]
null
null
null
notebook.ipynb
dnlrbns/pendcart
696c5d2c5fc7b787f3ab074e3ec3949a94dfc5ed
[ "MIT" ]
null
null
null
21.213115
90
0.51391
true
174
Qwen/Qwen-72B
1. YES 2. YES
0.90599
0.61878
0.560609
__label__yue_Hant
0.234876
0.140812
# The Harmonic Oscillator Strikes Back *Note:* Much of this is adapted/copied from https://flothesof.github.io/harmonic-oscillator-three-methods-solution.html This week we continue our adventures with the harmonic oscillator. The harmonic oscillator is a system that, when displaced from its equilibrium position, experiences a restoring force F proportional to the displacement x: $$F=-kx$$ The potential energy of this system is $$V = {1 \over 2}k{x^2}$$ These are sometime rewritten as $$ F=- \omega_0^2 m x, \text{ } V(x) = {1 \over 2} m \omega_0^2 {x^2}$$ Where $\omega_0 = \sqrt {{k \over m}} $ If the equilibrium value of the harmonic oscillator is not zero, then $$ F=- \omega_0^2 m (x-x_{eq}), \text{ } V(x) = {1 \over 2} m \omega_0^2 (x-x_{eq})^2$$ ## 1. Harmonic oscillator from last time (with some better defined conditions) Applying the harmonic oscillator force to Newton's second law leads to the following second order differential equation $$ F = m a $$ $$ F= -m \omega_0^2 (x-x_{eq}) $$ $$ a = - \omega_0^2 (x-x_{eq}) $$ $$ x(t)'' = - \omega_0^2 (x-x_{eq}) $$ The final expression can be rearranged into a second order homogenous differential equation, and can be solved using the methods we used above This is already solved to remind you how we found these values ```python import sympy as sym sym.init_printing() ``` **Note** that this time we define some of the properties of the symbols. Namely, that the frequency is always positive and real and that the positions are always real ```python omega0,t=sym.symbols("omega_0,t",positive=True,nonnegative=True,real=True) xeq=sym.symbols("x_{eq}",real=True) x=sym.Function("x",real=True) x(t),omega0 ``` ```python dfeq=sym.Derivative(x(t),t,2)+omega0**2*(x(t)-xeq) dfeq ``` ```python sol = sym.dsolve(dfeq) sol ``` ```python sol,sol.args[0],sol.args[1] ``` **Note** this time we define the initial positions and velocities as real ```python x0,v0=sym.symbols("x_0,v_0",real=True) ics=[sym.Eq(sol.args[1].subs(t, 0), x0), sym.Eq(sol.args[1].diff(t).subs(t, 0), v0)] ics ``` ```python solved_ics=sym.solve(ics) solved_ics ``` ### 1.1 Equation of motion for $x(t)$ ```python full_sol = sol.subs(solved_ics[0]) full_sol ``` ### 1.2 Equation of motion for $p(t)$ ```python m=sym.symbols("m",positive=True,nonnegative=True,real=True) p=sym.Function("p") sym.Eq(p(t),m*sol.args[1].subs(solved_ics[0]).diff(t)) ``` ## 2. Time average values for a harmonic oscillator If we want to understand the average value of a time dependent observable, we need to solve the following integral $${\left\langle {A(t)} \right\rangle}_t = \begin{array}{*{20}{c}} {\lim }\\ {\tau \to 0} \end{array}\frac{1}{\tau }\int\limits_0^\tau {A(t)dt} $$ ### 2.1 Average position ${\left\langle {x} \right\rangle}_t$ for a harmonic oscillator ```python tau=sym.symbols("tau",nonnegative=True,real=True) xfunc=full_sol.args[1] xavet=(xfunc.integrate((t,0,tau))/tau).limit(tau,sym.oo) xavet ``` The computer does not always make the best choices the first time. If you treat each sum individually this is not a hard limit to do by hand. The computer is not smart. We can help it by inseting an `expand()` function in the statement ```python xavet=(xfunc.integrate((t,0,tau))/tau).expand().limit(tau,sym.oo) xavet ``` ### 2.2 Excercise: Calculate the average momenta ${\left\langle {p} \right\rangle}_t$ for a harmonic oscillator ```python # Your code here m=sym.symbols("m",positive=True,nonnegative=True,real=True) p=sym.Function("p") sym.Eq(p(t),m*sol.args[1].subs(solved_ics[0]).diff(t)) tau=sym.symbols("tau",nonnegative=True,real=True) pfunc=sym.Eq(p(t),m*sol.args[1].subs(solved_ics[0]).diff(t)).args[1] pavet=(pfunc.integrate((t,0,tau))/tau).limit(tau,sym.oo) pavet ``` ### 2.3 Exercise: Calculate the average kinetic energy of a harmonic oscillator ```python # Your code here m=sym.symbols("m",positive=True,nonnegative=True,real=True) KE=sym.Function("KE") sym.Eq(KE(t),(m*sol.args[1].subs(solved_ics[0]).diff(t))**2/(2*m)) ``` ```python tau=sym.symbols("tau",nonnegative=True,real=True) KEfunc=sym.Eq(KE(t),(m*sol.args[1].subs(solved_ics[0]).diff(t))**2/(2*m)).args[1] KEavet=(KEfunc.integrate((t,0,tau))/tau).limit(tau,sym.oo) KEavet ``` ```python KEavet=(KEfunc.integrate((t,0,tau))/tau).expand().limit(tau,sym.oo) KEavet ``` ## 3. Ensemble (Thermodynamic) Average values for a harmonic oscillator If we want to understand the thermodynamics ensemble average value of an observable, we need to solve the following integral. $${\left\langle {A(t)} \right\rangle}_{T} = \frac{\int{A e^{-\beta H}dqdp}}{\int{e^{-\beta H}dqdp} } $$ You can think of this as a Temperature average instead of a time average. Here $\beta=\frac{1}{k_B T}$ and the classical Hamiltonian, $H$ is $$ H = \frac{p^2}{2 m} + V(q)$$ **Note** that the factors of $1/h$ found in the classical partition function cancel out when calculating average values ### 3.1 Average position ${\left\langle {x} \right\rangle}_t$ for a harmonic oscillator For a harmonic oscillator with equilibrium value $x_{eq}$, the Hamiltonian is $$ H = \frac{p^2}{2 m} + \frac{1}{2} m \omega_0 (x-x_{eq})^2 $$ First we will calculate the partition function $\int{e^{-\beta H}dqdp}$ ```python k,T=sym.symbols("k,T",positive=True,nonnegative=True,real=True) xT,pT=sym.symbols("x_T,p_T",real=True) ham=sym.Rational(1,2)*(pT)**2/m + sym.Rational(1,2)*m*omega0**2*(xT-xeq)**2 beta=1/(k*T) bolz=sym.exp(-beta*ham) z=sym.integrate(bolz,(xT,-sym.oo,sym.oo),(pT,-sym.oo,sym.oo)) z ``` Then we can calculate the numerator $\int{A e^{-\beta H}dqdp}$ ```python numx=sym.integrate(xT*bolz,(xT,-sym.oo,sym.oo),(pT,-sym.oo,sym.oo)) numx ``` And now the average value ```python xaveT=numx/z xaveT ``` ### 3.2 Exercise: Calculate the average momenta ${\left\langle {p} \right\rangle}_t$ for a harmonic oscillator After calculating the value, explain why you think you got this number ```python # your code here nump=sym.integrate(pT*bolz,(xT,-sym.oo,sym.oo),(pT,-sym.oo,sym.oo)) nump ``` ```python paveT=nump/z paveT ``` ### 3.3 Exercise: Calculate the average kinetic energy The answer you get here is a well known result related to the energy equipartition theorem ```python # Your code here numKE=sym.integrate((pT**2)/(2*m)*bolz,(xT,-sym.oo,sym.oo),(pT,-sym.oo,sym.oo)) numKE ``` ```python KEaveT=numKE/z KEaveT ``` # Back to the lecture ## 4. Exercise Verlet integrators In this exercise we will write a routine to solve for the equations of motion for a hamonic oscillator. Plot the positions and momenta (seprate plots) of the harmonic oscillator as a functions of time. Calculate trajectories using the following methods: 1. Exact solution 2. Simple taylor series expansion 3. Predictor-corrector method 4. Verlet algorithm 5. Leapfrog algorithm 6. Velocity Verlet algorithm ```python # Your code here ```
5da4b5239749aaa9408ca4110a87007295b39726
87,460
ipynb
Jupyter Notebook
harmonic_student.ipynb
sju-chem264-2019/new-10-14-10-m-jacobo
a80b342b8366f5203d08b8d572468b519067752c
[ "MIT" ]
null
null
null
harmonic_student.ipynb
sju-chem264-2019/new-10-14-10-m-jacobo
a80b342b8366f5203d08b8d572468b519067752c
[ "MIT" ]
null
null
null
harmonic_student.ipynb
sju-chem264-2019/new-10-14-10-m-jacobo
a80b342b8366f5203d08b8d572468b519067752c
[ "MIT" ]
null
null
null
93.540107
11,464
0.804574
true
2,225
Qwen/Qwen-72B
1. YES 2. YES
0.867036
0.746139
0.646929
__label__eng_Latn
0.880557
0.341364
# Sizing a mosfet using gm/Id method This is an example you can use to calculate mosfet size in Sky130 for given design parameters. You can change the parameters below and recalculate. ```python %pylab inline import numpy as np from scipy.interpolate import interp1d import pint ureg = pint.UnitRegistry() # convenient unit conversions ``` Populating the interactive namespace from numpy and matplotlib First we'll setup the design parameters. The mosfet length and width will need to be one of the bin values for the selected mosfet model. ```python A_v = np.abs(-2) # voltage gain at DC I_d = 0.5 * ureg.mA # maximum drain current f_c = 500 * ureg.MHz # corner (3dB) frequency C_L = 1 * ureg.pF # Load capacitance # simulation parameters sim_L = 0.15 * ureg.um # target mosfet length sim_W = 1 * ureg.um # calculations are independent of width but we need to have a matching bin value for the initial simulations sim_Vdd = 1.8 * ureg.V ``` First we calculate the load resistance. \begin{align} R_L &= \frac{1}{2 * \pi * f_c * C_L} \end{align} ```python R_L = 1 / (2 * 3.1415 * f_c * C_L) R_L = R_L.to(ureg.ohms) print(R_L) ``` 318.3192742320548 ohm Next we calculate transconductance. \begin{align} g_m &= \frac{A_v}{R_L} \end{align} ```python g_m = A_v / R_L g_m = g_m.to(ureg.mS) print(f'gm={g_m}') ``` gm=6.2829999999999995 millisiemens Now we need to generate the gm/Id graphs we'll need to determine the remaining values. These can be pre-generated and loaded or calculate here. We'll load them from an hdf5 file generated with _gen_gm_id_plots.py_. ```python import h5py f = h5py.File('gm_id_01v8/sky130_fd_pr__nfet_01v8__data.h5', 'r') bin_idx = 4 assert(f['bins'][bin_idx][1] - sim_L.magnitude < 0.00001) # index of the W=1 L=0.15 bin in the repo data. vsweep=f['vsweep'][bin_idx] * ureg.V gm_id = (f['gm'][bin_idx] * ureg.mS) / (f['id'][bin_idx] * ureg.A) id_W = (f['id'][bin_idx] * ureg.A / sim_W) ``` We could just look for the $\frac{I_d}{W}$ on the graph, but we've got the data and data interpolation tools, so we can calculate exactly. We'll figure out the value and plot it on the graph as a visual validation. ```python i_id_w__gm_id = interp1d(gm_id.magnitude, id_W.magnitude) id_interp = i_id_w__gm_id(g_m.magnitude) * id_W.units print(f'Id={id_interp.to(ureg.uA / ureg.um)}') ``` Id=63.30221617728767 microampere / micrometer ```python fig = figure() id_w__gm_id = fig.subplots(1, 1) id_w__gm_id.plot(gm_id.magnitude, id_W.magnitude) id_w__gm_id.axes.set_xlabel(f'gm/Id ({gm_id.units})') id_w__gm_id.axes.set_ylabel(f'Id/W ({id_W.units})') id_w__gm_id.plot(g_m.magnitude, id_interp.magnitude, 'o', markersize=8) fig.tight_layout() ``` This allows us to calculate the transistor width. \begin{align} W &= \frac{I_d}{\frac{I_d}{W}} \end{align} ```python W = I_d / id_interp W = W.to(ureg.um) print(f'W={W}') ``` W=7.898617618689249 micrometer Next we determine the gate bias using the same interpolation technique as above. ```python i_vgg__gm_id = interp1d(gm_id.magnitude, vsweep.magnitude) vbias_interp = i_vgg__gm_id(g_m.magnitude) * vsweep.units print(f'Vbias={vbias_interp}') fig = figure() gm_id__vgg = fig.subplots(1, 1) gm_id__vgg.plot(vsweep.magnitude, gm_id.magnitude) gm_id__vgg.axes.set_xlabel(f'Vgg ({vsweep.units})') gm_id__vgg.axes.set_ylabel(f'gm/Id ({gm_id.units})') gm_id__vgg.plot(vbias_interp.magnitude, g_m.magnitude, 'o', markersize=8) fig.tight_layout() ```
14f0905464a6d9cee459617aaf0502b60725b1bf
39,374
ipynb
Jupyter Notebook
utils/gm_id_example.ipynb
tclarke/sky130radio
4eca853b7e4fd6bc0d69998f65c04f97e73bee84
[ "Apache-2.0" ]
14
2020-09-28T19:41:26.000Z
2021-10-05T01:40:00.000Z
utils/gm_id_example.ipynb
tclarke/sky130radio
4eca853b7e4fd6bc0d69998f65c04f97e73bee84
[ "Apache-2.0" ]
null
null
null
utils/gm_id_example.ipynb
tclarke/sky130radio
4eca853b7e4fd6bc0d69998f65c04f97e73bee84
[ "Apache-2.0" ]
6
2020-07-30T21:54:19.000Z
2021-02-07T07:58:12.000Z
133.471186
16,484
0.893254
true
1,108
Qwen/Qwen-72B
1. YES 2. YES
0.875787
0.826712
0.724023
__label__eng_Latn
0.736974
0.520481

Math Notebooks

This repository contains mathematically informative ipython notebooks that were collated from OpenWebMath, RedPajama, and the Algebraic Stack in the AutoMathText effort. Zhang et. al. used Qwen 72B to score text with the following prompt:

<system>
You are ChatGPT, equipped with extensive expertise in mathematics and coding, and skilled
in complex reasoning and problem-solving. In the following task, I will present a text excerpt
from a website. Your role is to evaluate whether this text exhibits mathematical intelligence
and if it is suitable for educational purposes in mathematics. Please respond with only YES
or NO
</system>
  User: {
    “url”: “{url}”,
    “text”: “{text}”
}
1. Does the text exhibit elements of mathematical intelligence? Respond with YES or NO
2. Is the text suitable for educational purposes for YOURSELF in the field of mathematics? Respond with YES or NO

The responses to these questions were each scored with the function: LMScore()=exp(logit(YES))exp(logit(YES))+exp(logit(NO))LM–Score(\cdot) = \frac{exp(logit('YES'))}{exp(logit('YES')) + exp(logit('NO'))}

These scores are found in the meta.lm_q1_score and meta.lm_q2_score columns. A total score (meta.lm_q1q2_score) is achieved by taking the product of the two scores. LMScore(Q1,Q2)=LMScore(Q1)LMScore(Q2) LM–Score(Q_1, Q_2) = LM–Score(Q_1) \cdot LM–Score(Q_2)

Downloads last month
8
Edit dataset card