# PIVlab - particle image velocimetry (PIV) tool with GUI*PIVlab is a graphical user interface (GUI) based particle image velocimetry (PIV) software. It can be used to control OPTOLUTION's lasers, cameras and synchronizers, and of course it calculates the velocity distribution within imported (or captured) particle image pairs. It can also be used to derive, display and export multiple parameters of the flow pattern. The simple, GUI makes PIV data acquisition and data post-processing fast and efficient.*Listen to a podcast about PIVlab, its development and ideas for the future: [Inspiring Computing - PIVlab Unveiled: A Deep Dive into Particle Image Velocimetry with MATLAB](https://www.buzzsprout.com/2107763/15106425)![PIVlab_screenshot](https://github.com/Shrediquette/PIVlab/blob/main/images/PIVlab_screenshot.jpg)** ****PIVlab comes with it's own unique hardware: Pulsed lasers, LEDs, synchronizers and cameras are available here: [Optolution.com](https://www.optolution.com/en/products/particle-image-velocimetry-piv/)**** **Video tutorial 1/3: Quickstart guidehttps://youtube.com/watch?v=g2hcTRAzBvYVideo tutorial 2/3: Pre-processing, analysis and data validationhttps://youtube.com/watch?v=15RTs_USHFkVideo tutorial 3/3: Data exploration and data exporthttps://youtube.com/watch?v=47NCB_RFiE8PIVlab controlling cameras, lasers, etc.https://youtu.be/8B5M31NWlJc**Installation:** https://github.com/Shrediquette/PIVlab/wiki#installation-instructions**Please ask your questions in the PIVlab forum:** http://pivlab.blogspot.de/p/forum.html**Software documentation is available in the wiki:** https://github.com/Shrediquette/PIVlab/wiki** ****Code contributors:*** Main: William Thielicke (http://william.thielicke.org)* Name spaces / packages: Mikhil from MATHWORKS (https://github.com/Mikhil11)* Vectorization in piv_fftmulti: Sergey Filatov (http://www.issp.ac.ru/lqc/people.html)* GUI parallelization: Chun-Sheng Wang, ParaPIV (https://de.mathworks.com/matlabcentral/fileexchange/63358-parapiv)* Command line parallelization: Quynh M. Nguyen (https://github.com/quynhneo)* Speed, memory and general optimizations: Maarten (https://github.com/mkbosmans) via VORtech.nl via MathWorks** **We would like to acknowledge Uri Shavit, Roi Gurka & Alex Liberzon for sharing their code for 3-point Gaussian sub-pixel estimation. Thanks to Nima Bigdely Shamlo for allowing me to include the LIC function. Thanks to Raffel et al. for writing the book "Particle Image Velocimetry, A Practical Guide", which was a very good help. Thanks to the [thousands of publications that use PIVlab for research](https://scholar.google.de/scholar?cites=819244312015141543)!Visit Matlabs File exchange site for PIVlab: [![View PIVlab - particle image velocimetry (PIV) tool on File Exchange](https://www.mathworks.com/matlabcentral/images/matlab-file-exchange.svg)](https://de.mathworks.com/matlabcentral/fileexchange/27659-pivlab-particle-image-velocimetry-piv-tool)PIVlab [can be run online using MATLAB online](https://youtu.be/EQHfAmRxXw4?si=X77HabqAIbuHRIGT). MATLAB online is free (after registration) with a limited usage time per user (20 hrs/month):[![Open in MATLAB Online](https://www.mathworks.com/images/responsive/global/open-in-matlab-online.svg)](https://matlab.mathworks.com/open/github/v1?repo=Shrediquette/PIVlab&file=PIVlab_GUI.m)

O GAMMA-GUI é uma interface gráfica amigável e intuitiva, desenvolvida na plataforma Matlab®, que não requer conhecimentos de programação. Ele facilita a aplicação de métodos de análise multivariada, uma área também conhecida como quimiometria, dedicada à análise de dados de origem química. O GAMMA-GUI é projetado tanto para usuários experientes quanto para aqueles que estão iniciantes e não familiarizados com linguagens de programação, proporcionando uma experiência simplificada e acessível na utilização de diversos recursos quimiométricos.Esse pacote é livremente distribuído, os autores não se responsabilizam pelos resultados obtidos através da livre utilização dessas rotinas, sua comercialização e modificação não está autorizada.GAMMA-GUI is a user-friendly and intuitive graphical interface developed on the Matlab® platform, which does not require programming knowledge. It facilitates the application of multivariate analysis methods, an area also known as chemometrics, dedicated to analyzing data of chemical origin. GAMMA-GUI is designed for experienced users and beginners unfamiliar with programming languages, providing a simplified and accessible experience in utilizing various chemometric tools.This package is freely distributed, and the authors are not responsible for the results obtained through the unrestricted use of these routines. Its commercialization and modification are not authorized.

The FOMCON toolbox for MATLAB is a fractional-order calculus based toolbox for system modeling and control design.

* * * The functions on this page are no longer being updated. They should still work as shown in the examples here, but I am only actively maintaining the versions of these functions which are in the Climate Data Toolbox for MATLAB, which can be found here https://www.mathworks.com/matlabcentral/fileexchange/70338. * * *This submission contains functions to plot the outlines and names of National borders and US states. Matlab's Mapping Toolbox is NOT required. There are two functions for plotting: borders and bordersm, and they both work the same way, except that bordersm is for use with maps created using Matlab's Mapping Toolbox. Similarly, labelborders and labelbordersm place text labels within the boundaries of countries or states.

Check out the Examples tab ^^^.This function is intended to streamline the process of making gifs. Simply call gif('myfile.gif') to first the first frame, and then call gif to write each subsequent frame. That's it.

SMOOTHN provides a fast, unsupervised and robust discretized spline smoother for data of arbitrary dimension.SMOOTHN(Y) automatically smoothes the uniformly-sampled array Y. Y can be any N-D multicomponent noisy array (e.g. time series, images, 3D data, 3D vector fields, tensors...). To smooth a vector field or multi-component data, Y must be a cell array. For example, if you need to smooth a 3-D vectorial flow (Vx,Vy,Vz), use Y = {Vx,Vy,Vz}. The output Z is also a cell array which contains the smoothed components.SMOOTHN can deal with missing (NaN) values (see screenshot and examples).SMOOTHN(...,'robust') carries out a robust smoothing that minimizes the influence of outlying data (see screenshot and examples).SMOOTHN is made unsupervised by the minimization of the generalized cross-validation score.Enter "help smoothn" in the Matlab command window for complete instructions and 1-D to 3-D examples.A series of 8 documented examples is available here:http://www.biomecardio.com/matlab/smoothn_doc.html-----When using this algorithm, please refer to these 2 papers:1) Garcia D. Robust smoothing of gridded data in one and higher dimensions with missing values.Comput Statist Data Anal, 2010;54:1167-1178http://www.biomecardio.com/publis/csda10.pdf2) Garcia D. A fast all-in-one method for automated post-processing of PIV data.Exp Fluids, 2011;50:1247-1259.http://www.biomecardio.com/publis/expfluids11.pdf-----

pcolor in polar coordinatespolarPcolor draws a pseudocolor plot in polar coordinates with a polar grid.SummarypolarPcolor aims to represent a pseudocolour plot in polar coordinates, with a radial grid to allow clear visualization of the data. It is well suited for Plan Position Indicator (PPI) scan for radar or lidar for example [1]. A similar function is available in ref. [2], which propose a visualization in 3D.References[1] Cheynet, E., Jakobsen, J. B., Snæbjörnsson, J., Reuder, J., Kumer, V., & Svardal, B. (2017). Assessing the potential of a commercial pulsed lidar for wind characterisation at a bridge site. Journal of Wind Engineering and Industrial Aerodynamics, 161, 17-26. http://dx.doi.org/10.1016/j.jweia.2016.12.002[2] http://www.mathworks.com/matlabcentral/fileexchange/13200-3d-polar-plot

Y = INPAINTN(X) replaces the missing data in X by extra/interpolating the non-missing elements. The non finite values (NaN or Inf) in X are considered as missing data. X can be any N-D array.Type "help inpaintn" in the Matlab command windows for several examples.INPAINTN (no input/output argument) runs a 3-D example. Important note:----------------INPAINTN uses an iterative process that converges toward the solution. Y = INPAINTN(X,N) uses N iterations. By default, N = 100. If you estimate that INPAINTN did not totally converge, then increase N: Y = INPAINTN(X,1000);----- When using this algorithm, please refer to these 2 papers:1) Garcia D. Robust smoothing of gridded data in one and higher dimensions with missing values. Comput Statist Data Anal, 2010;54:1167-1178 http://www.biomecardio.com/publis/csda10.pdf2) Wang G, Garcia D et al. A three- dimensional gap filling method for large geophysical datasets: Application to global satellite soil moisture observations.Environ Modell Softw, 2012;30:139-142.http://www.biomecardio.com/publis/envirmodellsoftw12.pdf.pdf -----A series of examples is available here:http://www.biomecardio.com/matlab/inpaintn_doc.html Example:--------%% ---- 2-D data ---- %%n = 256;y0 = peaks(n);y = y0;I = randperm(n^2);y(I(1:n^2*0.5)) = NaN; % lose 1/2 of datay(40:90,140:190) = NaN; % create a holez = inpaintn(y,200); % inpaint datasubplot(2,2,1:2), imagesc(y), axis equal offtitle('Corrupt data')subplot(223), imagesc(z), axis equal offtitle('Recovered data ...')subplot(224), imagesc(y0), axis equal offtitle('... compared with original data')------http://www.biomecardio.com-----

Fitness-Distance Balance (FDB): A New Selection Method for Meta-Heuristic Search Algorithms

These colormaps were developed by Kristen Thyng using viscm. They are perceptually uniform, as color should be when it serves as a numeric axis. If these colormaps are useful for you, please consider citing our paper: Thyng, K.M., C.A. Greene, R.D. Hetland, H.M. Zimmerle, and S.F. DiMarco. 2016. True colors of oceanography: Guidelines for effective and accurate colormap selection. Oceanography 29(3):9–13. http://dx.doi.org/10.5670/oceanog.2016.66

ATheNA is a Search-Based Software Testing framework that combines an automatically-generated and a manually-defined fitness functions to search for failure-revealing test cases. On one hand, the automatic fitness function is generated using S-TaLiRo directly from the requirement under analysis. On the other hand, the manual fitness function must be written by the user employing their domain knowledge and expertise on the model.

Damping ratio estimation from ambient vibrations (SDOF)SummaryIf the free-decay response (FDR) of a Single Degree-of-Freedom (SDOF) system is not directly available, it is possible to use ambient vibrations data yo estimate the modal damping ratio. Here, the Random Decrement Technique (RDT) [1], as well as the Natural Excitation Technique (NExT) [2], are used. First, the response of a SDOF to white noise is simulated in the time domain using [3]. Then the IRF is computed using the RDT or NExT. Finally, and an exponential decay is fitted to the envelop of the IRF to obtain the modal damping ratio.ContentThe present submission contains:a function RDT.,m that implements to Random Decrement Technique (RDT)a function NExT that implements the Natural Excitation Technique (NExT)a function expoFit that determine the modal damping ratio by fitting an exponential decay to the envelope of the IRF.a function CentDiff used to simulate the response to a white noise load of a SDOF in the time domain.An example file Example.mAny question, comment or suggestion is welcomed.References[1] Ibrahim, S. R. (1977). Random decrement technique for modal identification of structures. Journal of Spacecraft and Rockets, 14(11), 696-700.[2] James III, O. H., & Came, T. G. (1995). The natural excitation technique (next) for modal parameter extraction from operating structures.[3] http://www.mathworks.com/matlabcentral/fileexchange/53854-harmonic-excitation-of-a-sdof

Click on the Examples Tab ^^^ for detailed descriptions of AMT functions. This toolbox is for importing, analyzing, and displaying Antarctica-related data. AMT is designed to provide a standard framework to allow easy pairing of multiple different types of data sets (surface elevation, ice velocity, grounding line, etc). For a quick overview, check the Examples tab on this page and click "AMT Getting Started". To find data-specific plugins for this toolbox, search the File Exchange site for "AMT".Note to users: AMT was originally written to be used with Matlab's Mapping Toolbox. However, Matlab's Mapping Toolbox is sometimes inefficient and difficult to work with. And depending on Matlab's Mapping Toolbox makes it harder to share codes. So I've been moving more toward plotting mostly in polar stereographic meters. There is a suite of functions ending in "ps" that make this easy. If AMT is useful for you, please cite our paper!

Arctic Mapping ToolsThis is a Northern-hemisphere edition of Antarctic Mapping Tools for MATLAB.DocumentationMost of the functions in this GitHub repo directly mimic functions in the Antarctic version, and that's where you'll find the best documentation for the Arctic tools.Most of the functions in this toolbox end with the letter n to indicate the northern hemisphere version of the Antarctic tools. For example, The Arctic function plotpsn is equivalent to the Antarctic plotps function.PluginsHere are some Greenland datasets that are designed to work with Arctic Mapping Tools:BedMachine Greenland and Antarctic ice thickness, bed elevation, surface elevation, and masks.ITS_LIVE global ice velocity mosaics.Check the File Exchange for potentially more datasets, or email me if you something specific in mind that you'd like to see.Citing Antarctic Mapping ToolsIf these functions are useful for you, please cite our paper as follows:Greene, C. A., Gwyther, D. E., & Blankenship, D. D. (2017). Antarctic Mapping Tools for Matlab. Computers & Geosciences, 104, 151–157. Elsevier BV. https://doi.org/10.1016/j.cageo.2016.08.003or in BibTeX if you prefer:@article{greene2017antarctic, title={{Antarctic Mapping Tools for MATLAB}}, author={Greene, Chad A and Gwyther, David E and Blankenship, Donald D}, journal={Computers \& Geosciences}, volume={104}, pages={151--157}, year={2017}, publisher={Elsevier}, doi={10.1016/j.cageo.2016.08.003}}

Description---------------The toolbox facilitates simultaneous simulation of EnergyPlus and Matlab (co-simulation). The main component is the mlep class containing all the necessary tools to configure and run EnergyPlus co-simulation within the Matlab environment.System Requirements-----------------------------* Windows. The toolbox has only been tested for Windows, but considerable preparations for other OS has already been done.* EnergyPlus installed. You can obtain the software here https://energyplus.net/. If you install the EnergyPlus to the default location ('C:\EnergyPlusVx-x-x') then it might be detected automatically by the toolbox. Installation--------Obtain a copy of the toolbox from* Matlab Add-on Manager* or Mathworks File Exchange https://uk.mathworks.com/matlabcentral/fileexchange/69074-energyplus-co-simulation-toolbox* or a GitHub repository https://github.com/dostaji4/EnergyPlus-co-simulation-toolbox/releasesand install. Features-----------The toolbox contains:* Parsing of the IDF file to determine co-simulation inputs/outputs.* Automatic socket communication configuration (on localhost).* Background start of the EnergyPlus process with an output to the Matlab command line.* System Object implementation usable in Matlab & Simulink.* Bus input/output integration for easy Simulink model setup.Examples-------------See the GettingStarted.mlx guide delivered with the Matlab toolbox or the documentation residing under Help -> Supplemental Software -> EnergyPlus co-simulation toolboxTroubleshooting---------------------* Always be sure that EnergyPlus itself is working. To check run "EP-Launch.exe" from the EnergyPlus installation folder and try running one of its examples (located at /ExampleFiles/). * If you have issues with "EnergyPlus not found." run "setupMlep.m".* If you have an issue with a "Vector to Bus" block not having its bus types correctly specified, run the model again. Bus objects should now be in the workspace and it should work. Copyright (C) 2019, Jiri Dostal (jiri.dostal@cvut.cz)All rights reserved.This software builds on the free software by Truong Nghiem(truong@seas.upenn.edu), Willy Bernal (Willy.BernalHeredia@nrel.gov) and several other third-party open-source tools.

Fast Gradient Vector Flow This package implements the Gradient Vector Flow (GVF) in C++/MEX.The C++/MEX implementation of Gradient Vector Flow (GVF) is much faster than the Matlab implementation.There is a demo.m file in this package, which shows how to run a simple demo.The package is used by:[1] Quan Wang, Kim L. Boyer, "The active geometric shape model: A new robust deformable shape model and its applications", Computer Vision and Image Understanding, Volume 116, Issue 12, December 2012, Pages 1178-1194, ISSN 1077-3142, 10.1016/j.cviu.2012.08.004.

# gramm [![View gramm on File Exchange](https://www.mathworks.com/matlabcentral/images/matlab-file-exchange.svg)](https://mathworks.com/matlabcentral/fileexchange/54465-gramm-data-visualization-toolbox)Gramm is a MATLAB toolbox that enables the rapid creation of complex, publication-quality figures. Its design philosophy focuses on a *declarative* approach, where users specify the desired end result, as opposed to the traditional *imperative* method involving for loops, if/else statements, etc.The MATLAB implementation of `gramm` is inspired by the "grammar of graphics" principles ([Wilkinson 1999](http://www.springer.com/de/book/9781475731002)) and the [ggplot2](http://ggplot2.tidyverse.org/) library for R by Hadley Wickham. As a reference to this inspiration, gramm stands for **GRAM**mar of graphics for **M**ATLAB. A similar library called [Seaborn](https://seaborn.pydata.org) also exists for Python.Gramm has been used in many publications from varied fields and is particularily suited for neuroscience, from human movement psychophysics ([Morel et al. 2017](https://doi.org/10.1371/journal.pbio.2001323)), to electrophysiology ([Morel et al. 2016](https://doi.org/10.1088/1741-2560/13/1/016002); [Ferrea et al. 2017](https://doi.org/10.1152/jn.00504.2017)), human functional imaging ([Wan et al. 2017](https://doi.org/10.1002/hbm.23932)) and animal training ([Berger et al. 2017](https://doi.org/10.1152/jn.00614.2017)).- [Demo live scripts](#demo-live-scripts)- [Workflow](#workflow)- [About gramm](#about-gramm) - [Installation](#Installation) - [Documentation](#Documentation) - [Citing gramm](#citing-gramm)- [Features](#features)- [Gallery](#gallery)## Demo live scripts ##Typical use cases are described in these live scripts. We recommend opening the live scripts in MATLAB to benefit from interactive elements. A simplified workflow is presented below this table.To run the files in Matlab online, you will need to add the gramm folder to your path (select the gramm folder in the files panel on the left, right click>Add to Path>Selected Folder(s)).- **Getting Started:** [👀 Preview](http://htmlpreview.github.io/?https://github.com/piermorel/gramm/blob/master/gramm/html/GettingStarted.html) [![Open in MATLAB Online](https://www.mathworks.com/images/responsive/global/open-in-matlab-online.svg)](https://matlab.mathworks.com/open/github/v1?repo=piermorel/gramm&file=gramm/doc/GettingStarted.mlx)- **Explore grouped data:** [👀 Preview](http://htmlpreview.github.io/?https://github.com/piermorel/gramm/blob/master/gramm/html/Groups.html) [![Open in MATLAB Online](https://www.mathworks.com/images/responsive/global/open-in-matlab-online.svg)](https://matlab.mathworks.com/open/github/v1?repo=piermorel/gramm&file=gramm/doc/Groups.mlx)- **Explore X/Y data:** [👀 Preview](http://htmlpreview.github.io/?https://github.com/piermorel/gramm/blob/master/gramm/html/XY.html) [![Open in MATLAB Online](https://www.mathworks.com/images/responsive/global/open-in-matlab-online.svg)](https://matlab.mathworks.com/open/github/v1?repo=piermorel/gramm&file=gramm/doc/XY.mlx)- **Explore Time Series data:** [👀 Preview](http://htmlpreview.github.io/?https://github.com/piermorel/gramm/blob/master/gramm/html/TimeSeries.html) [![Open in MATLAB Online](https://www.mathworks.com/images/responsive/global/open-in-matlab-online.svg)](https://matlab.mathworks.com/open/github/v1?repo=piermorel/gramm&file=gramm/doc/TimeSeries.mlx)- **Advanced examples:** [👀 Preview](http://htmlpreview.github.io/?https://github.com/piermorel/gramm/blob/master/gramm/html/examples.html) [![Open in MATLAB Online](https://www.mathworks.com/images/responsive/global/open-in-matlab-online.svg)](https://matlab.mathworks.com/open/github/v1?repo=piermorel/gramm&file=gramm/doc/examples.mlx)## WorkflowThe typical workflow to generate this figure with only 7 lines of code is detailed in the ["Getting Started" live script.](#demo-live-scripts). The figure uses data from the carbig dataset and represents the evolution of fuel economy of new cars with time, depending on the number of cylinders indicated by color, and regions of origin separated across subplot columns.Here are the main steps to generate this figure:1. Provide gramm with the relevant data for the figure: X and Y variables, but also the variables that will determine color, subplot rows/columns, etc.```matlabload example_data.mat %Load example dataset about cars% Create a gramm object g, provide x (year of production) and y (fuel economy) data,% color grouping data (number of cylinders) and select a subset of the data (even numbers of cylinders)g=gramm('x',cars.Model_Year,'y',cars.MPG,'color',cars.Cylinders,... 'subset',~mod(cars.Cylinders,2);% Subdivide the data in subplots horizontally by region of origing.facet_grid([],cars.Origin_Region);```2. Add graphical layers to your figure: raw data layers (directly plot data as points, lines...) or statistical layers (fits, histograms, densities, summaries with confidence intervals...). One instruction is enough to add each layer, and all layers offer many customization options.```matlab % Plot raw data as points with a small horizontal offset between groupsg.geom_point("dodge",0.5);% Plot linear fits of the datag.stat_glm(); ```3. Optionally configure legends, title and adjust the look the figure (colors, axes, etc.)```matlab% Set appropriate names for legendsg.set_names('column','Origin', 'x','Year of production', 'y','Fuel economy (MPG)',... 'color','# Cylinders');%Set figure titleg.set_title('Fuel economy of new cars between 1970 and 1982');```4. Draw the figure, gramm takes care of all the annoying parts: no need to loop over colors or subplots, colors and legends are generated automatically, axes limits are taken care of, etc.```matlabg.draw();```## About gramm ##### Installing gramm ###We recommend installing gramm directly through MATLAB's Add-ons explorer. Search for "gramm" and click Add!You can also install gramm manually by downloading the latest .mltbx file or by adding the gramm folder from the repository to your path.### Documentation ###Once the toolbox is installed, type ```doc``` in the MATLAB command window and you will see gramm in the "Supplemental Software" section at the bottom of the left navigation bar. From there you will have access to several live script demos and a cheat sheet with all commands in a compact format.### Citing gramm ###Gramm has been published in the Journal of Open Source Software. If you use gramm plots in a publication you can thus cite it using the following:[![DOI](http://joss.theoj.org/papers/10.21105/joss.00568/status.svg)](https://doi.org/10.21105/joss.00568)Morel, (2018). Gramm: grammar of graphics plotting in Matlab. Journal of Open Source Software, 3(23), 568, https://doi.org/10.21105/joss.00568### Compatibility ### Recent versions of gramm (3.0 and above) target MATLAB above R2018b. Older releases work in older MATLAB versions. The statistics toolbox is required for some methods: stat_glm(), some stat_summary() methods, stat_density(). The curve fitting toolbox or the statistics toolbox is required for stat_fit().## Main Features- Accepts X, Y, Z and grouping data in varied types and shapes (arrays, matrices, cells)- Multiple ways of separating groups of data: - Colors, lightness, point markers, line styles, and point/line size ('color', 'lightness', 'marker', 'linestyle', 'size') - Subplots by row and/or columns, or wrapping columns (facet_grid() and facet_wrap()). Multiple options for consistent axis limits across facets, rows, columns, etc. (using 'scale' and 'space') - Separate figures (fig())- Multiple ways of directly plotting the data: - scatter plots (geom_point()) and jittered scatter plot (geom_jitter()) - lines (geom_line()) - pre-computed confidence intervals (geom_interval()) - bars plots (geom_bar()) - raster plots (geom_raster()) - labels (geom_label()) - point counts (geom_count()) - swarm / beeswarm plots (geom_swarm()) - text labels (geom_label())- Multiple statistical visualizations on the data: - y data summarized by x values (uniques or binned) with confidence intervals (stat_summary()) - histograms and density plots of x values (stat_bin() and stat_density()) - box and whisker plots (stat_boxplot()) - violin plots (stat_violin()) - quantile-quantile plots (stat_qq()) of x data distribution against theoretical distribution or y data distribution. - Smoothed data (stat_smooth()) - 2D binning (stat_bin2d()) - GLM fits (stat_glm(), requires statistics toolbox) - Custom fits with user-provided anonymous function (stat_fit()) - Ellipses of confidence (stat_ellipse())- Easy export in multiple formats with a convenient export() method that can be called after draw() and maintains correct dimensions/aspect ratio. - All visualizations have plenty of options accessible through arguments, from computational to esthetic ones.- Representation of groupings can be fully customized (colormaps, ordering)- Multiple gramm plots can be combined in the same figure by creating a matrix of gramm objects and calling the draw() method on the whole matrix.- MATLABs axes properties are modifiable through the method axe_property()- Non-data graphical elements can be added such as reference lines or polygons (geom_abline(), geom_vline(),geom_hline(),geom_polygon())- For advanced customization, handles of all graphic elements and computation results are easily available after the draw() through the results structure of the gramm object## GalleryAll these examples are from the [advanced examples live scripts](#demo-live-scripts)### Superimposition of gramm objects on the same axes### Custom layouts ###### Grid and scaling options ###### Colormap and legend options ##### Acknowledgementsgramm was inspired and/or used code from:- [ggplot2](http://ggplot2.org)- [Panda](http://www.neural-code.com/index.php/panda) for color conversion- [subtightplot](http://www.mathworks.com/matlabcentral/fileexchange/39664-subtightplot) for subplot creation- [colorbrewer2](http://colorbrewer2.org)- [viridis colormap](https://bids.github.io/colormap/)

Hybrid Equations ToolboxThe Hybrid Equation (HyEQ) Toolbox provides MATLAB and Simulink libraries for the simulation of hybrid dynamical systems. The Toolbox supports definitions of hybrid systems with inputs, allowing for the creation of interconnected hybrid systems in modular configurations. The hybrid arcs output by simulations can be transformed and plotted with a suite of tools that allow easy customization. Detailed documentation and numerous examples are provided in the MATLAB Help browser or at hyeq.github.io.RequirementsInstalling v3.0 of the HyEQ Toolbox requires MATLAB R2014b or newer.This toolbox officially supports the following combinations of operating system and MATLAB/Simulink version:Windows: R2014b-R2022bMac (MATLAB only): R2014b-R2022bMac (MATLAB+Simulink): R2016a-R2022bLinux: R2021a-R2022bMATLAB versions R2014b through R2015b are not compatible with recent versions of macOS, such as macOS Monterey. See MATLAB and Simulink's system requirements to find a compatible OS/software version pair.When the Toolbox was tested on Linux in MATLAB R2014b, Simulink caused the automated test runner to crash. Manual testing indicates that the HyEQ MATLAB library might work, but use at your own risk. For a MATLAB version tested with Linux, use R2021a or later (earlier versions than 2021a may work but were not tested).How to Install the HyEQ Toolbox version 3.0Before installing version 3.0 of the HyEQ Toolbox, it is necessary to manually uninstall any installed earlier versions (v2.04 or earlier). Subsequently, it is not necessary to manually uninstall the HyEQ Toolbox (v3.0 or later) before updating to a newer version.Uninstalling HyEQ Toolbox Version 2.04.The process for uninstalling v2.04 is as follows (earlier versions are similar).Open Matlab.Navigate to the HyEQ Toolbox folder. The toolbox folder can be located by running which('HyEQsolver') in the MATLAB command window (note that HyEQsolver is in a subdirectory of the HyEQ Toolbox folder).On Windows, the HyEQ Toolbox folder path is typically C:\Program Files\Matlab\toolbox\HyEQ_Toolbox_v204.On Macintosh, the HyEQ Toolbox folder path is typically ~/matlab/HyEQ_Toolbox_v204.While in the HyEQ Toolbox folder, run the uninstallation script tbclean in the MATLAB command window. This script deletes all the files in the HyEQ Toolbox folder!Restart Matlab.Check that the HyEQ Toolbox is uninstalled by running which('HyEQsolver'). The output should be 'HyEQsolver' not found.Installing v3.0 via the Add-On Explorer (MATLAB R2017b and later)On MATLAB R2017b and later, the HyEQ Toolbox can be installed through the MATLAB Add-on Explorer.Open MATLABSelect the “Home” tab at the top of the window.Click the “Add-Ons” button to open the Add-On explorer.Search for “Hybrid Equations Toolbox” and select the entry by Ricardo Sanfelice.Click the “Add” button to open a drop-down menu and select “Add to MATLAB”.A license agreement will open. Click “I Accept” to start the installation.When the installation is complete, a “Getting Started” guide will open in MATLAB with instructions for next steps.If the above steps do not work because the Add-On Explorer is unavailable, then you can install the toolbox using the steps described below for installing without the Add-On Explorer.Installing v3.0 Without the Add-On Explorer (MATLAB R2014b through R2017a)The MATLAB Add-on Manager is not supported on versions of MATLAB before MATLAB R2017b, so for these versions the HyEQ Toolbox must be installed by the following process.Open the Hybrid Equations Toolbox page on the MATLAB Central File Exchange.Click “Download” and select “Toolbox” from the drop-down menu.Select any convenient location to save the .mltbx file.Open the .mltbx file in MATLAB.A dialog box will prompt you to install the toolbox. Click “Install.”To finish setting up the toolbox, run hybrid.configureToolbox in the MATLAB command window. This commandchecks that only one version of the toolbox is installed,upgrades the Simulink library and example model files to the current MATLAB version (this prevents warnings that they were last saved on an old version of Simulink), andopens a prompt to run automated tests (there will be several skipped tests for functionality that is not tested on older versions of MATLAB).You may delete the .mltbx file at this point.Help Using the ToolboxTo access the HyEQ Toolbox documentation, open MATLAB Help (F1) and navigate to Supplemental Software>Hybrid Equations Toolbox.The documentation is also available online at hyeq.github.io.To ask for help, report a problem, or request a feature, please submit an issue on GitHub.TroubleshootingProblem: When I call HybridSystem.solve(), after installing v3.0, the following error appears: “Error using HyEQsolver. Too many input arguments.”Cause: A previous version of the toolbox is still installed.Solution: Uninstall the previous hybrid toolbox version by following the steps above.Problem: Opening a Simulink example model produces the following error:File '\Examples\+hybrid\+examples\+\.slx' cannot be loaded because it isshadowed by another file of the same name higher on the MATLAB path. For more information see "Avoiding Problems with Shadowed Files" in the Simulink documentation.The file that is higher on the MATLAB path is: .Solution: Either rename the example file name or rename the file that is shadowing it (or remove it from the MATLAB Path). After renaming the example file to , you can open the model to by running hybrid.examples.. or by navigating to it in the file browser. Links to open the example from the MATLAB Help browser will no longer work.Problem: A Simulink model produces the following error message:An error occurred while running the simulation and the simulation was terminatedSimulink cannot solve the algebraic loop containing '/Integrator System/ICx' at time 0.0 using the TrustRegion-based algorithm due to one of the following reasons: the model is ill-defined i.e., the system equations do not have a solution; or the nonlinear equation solver failed to converge due to numerical issues.Cause: The Simulink model contains an algebraic loop (a closed signal loop that contains only direct feedthrough blocks) that is preventing Simulink from propagating the dynamics of the system.Solution: For one of the HyEQ blocks in the loop, use the “x-” output instead of the “x” output to pass the output to the next block in the loop. This introduces a one time-step delay to the output signal in order to break the algebraic loop.CreditsVersion 2.04Version 2.04 of the Hybrid Equations Toolbox was developed byRicardo G. Sanfelice, David A. Copp, and Pablo Nanez.Version 3.0Version 3.0 of the HyEQ Toolbox was developed by Paul Wintz.See Credits and Acknowledgments in the HyEQ Toolbox documentation for further acknowledgments.See AlsoWeb-based DocumentationHybrid Systems Laboratory at UC, Santa CruzPrevious versions of the HyEQ ToolboxExamples of Hybrid Systems (blog)

AboutA simple Matlab function for Fabio Crameri's perceptually uniform scientific colormaps.Usagecrameri without any inputs displays the options for colormaps.crameri ColormapName sets the colormap of the current axes.cmap = crameri('ColormapName') returns a 256x3 colormap. For a visual depiction of valid colormap names, type crameri.cmap = crameri('-ColormapName') a minus sign preceeding any ColormapName flips the order of the colormap.cmap = crameri(...,NLevels) specifies a number of levels in the colormap. Default value is 256.cmap = crameri(...,'pivot',PivotValue) centers a diverging colormap such that white corresponds to a given value and maximum extents are set using current caxis limits. If no PivotValue is set, 0 is assumed.CitationCrameri, Fabio. (2021). Scientific colour maps (7.0.1). Zenodo. https://doi.org/10.5281/zenodo.5501399

To transfer the learnable parameters from pre-trained 2D ResNet-18 (ImageNet) to 3D one, we duplicated 2D filters (copying them repeatedly) through the third dimension. This is possible since a video or a 3D image can be converted into a sequence of image slices. In the training process, we expect that the 3D ResNet-18 learns patterns in each frame. This model has 34 million learnable parameters. simply, call "resnet18TL3Dfunction()" function.

TraCI4MatlabTraCI4Matlab is an implementation of the TraCI (Traffic Control Interface) protocol that allows the user to interact with SUMO (Simulation of Urban MObility, www.sumo-sim.org) in a client-server scenario in which Matlab acts as the client, and SUMO as the server. TraCI4Matlab is compatible with TraCI version 15 and previous versions.Requirements: MATLAB 8.0 (R2012b) or above SUMO simulator (www.sumo-sim.org) Recommended set up: Add the traci4matlab directory to your Matlab path Add traci4matlab.jar to the Matlab static java directory Citing TraCI4MatlabIf you use TraCI4Matlab in your research reports, articles and conferences, please cite it, as follows:@incollection{acosta_etal_2015, title = {{TraCI}4Matlab: {Enabling} the {Integration} of the {SUMO} {Road} {Traffic} {Simulator} and {Matlab}® {Through} a {Software} {Re}-engineering {Process}}, shorttitle = {{TraCI}4Matlab}, url = {http://link.springer.com/10.1007/978-3-319-15024-6_9}, urldate = {2017-03-06}, booktitle = {Modeling {Mobility} with {Open} {Data}}, publisher = {Springer}, author = {Acosta, Andrés F. and Espinosa, Jorge E. and Espinosa, Jairo}, year = {2015}, pages = {155--170} }

Mode shapes extraction by time domain decomposition (TDD)SummaryThe Time domain decomposition (TDD) [1] is an output-only method to extract mode shapes of a structure. Here, the modal damping ratios and modal displacements are in addition extracted using the functions presented in [6]. The TDD is similar to a more popular technique called Frequency-domain method (FDD) that was introduced by [2,3]. A good example of the FDD already exists on the Matlab File Exchange [4]. In a previous version, the present submission contained a function for the FDD. This function has been modified and moved to a new submission [5].ContentThe submission contains:The function TDD.m: function to apply the TDD method.An example file Example1.mAcceleration data beamData.m (4 Mb)References[1] Byeong Hwa Kim, Norris Stubbs, Taehyo Park, A new method to extract modal parameters using output-only responses, Journal of Sound and Vibration, Volume 282, Issues 1–2, 6 April 2005, Pages 215-230, ISSN 0022-460X, http://dx.doi.org/10.1016/j.jsv.2004.02.026.[2] Brincker, R.; Zhang, L.; Andersen, P. (2001). "Modal identification of output-only systems using frequency domain decomposition". Smart Materials and Structures 10 (3): 441. doi:10.1088/0964-1726/10/3/303.[3] BRINCKER, Rune, ZHANG, Lingmi, et ANDERSEN, P. Modal identification from ambient responses using frequency domain decomposition. In: Proc. of the 18*‘International Modal Analysis Conference (IMAC), San Antonio, Texas. 2000[4] http://www.mathworks.com/matlabcentral/fileexchange/50988-frequency-domain-decomposition--fdd-[5] https://se.mathworks.com/matlabcentral/fileexchange/57153-automated-frequency-domain-decomposition--afdd-[6] https://se.mathworks.com/matlabcentral/fileexchange/55557-modal-parameters-identification-from-ambient-vibrations--sdof

A novel Stochastic Fractal Search Algorithm with Fitness-Distance Balance for Global Numerical OptimizationPlease click for the article: https://www.sciencedirect.com/science/article/abs/pii/S2210650220304740Please click for the article of FDB method: https://www.sciencedirect.com/science/article/abs/pii/S0950705119305167Please click for the FDB-SOS algorithm: https://www.mathworks.com/matlabcentral/fileexchange/72311-fdb-sos

TopoToolbox provides a set of Matlab functions that support the analysis of relief and flow pathways in digital elevation models. The major aim of TopoToolbox is to offer helpful analytical GIS utilities in a non-GIS environment in order to support the simultaneous application of GIS-specific and other quantitative methods.TopoToolbox enables calculation of standard terrain attributes such as- slope- curvature- aspect- local topography- ...flow related terrain attributes such as- drainage basin delineation- flow accumulation- flow distance- ...stream network analysis such as- stream order- slope-area plots- chiplotsMoreover, TopoToolbox contains several tools to modify stream networks in an automated way and derive swath profiles, among other tools. The algorithms are fast and can thus be used in spatially distributed, dynamic modelling approaches in hydrology, glaciology and geomorphology. See http://topotoolbox.wordpress.com for examples and instructions.

Point cloud tools for MatlabNote: If you just want to align 2 point clouds with the ICP algorithm, check out a newer and simpler solution called simpleICP (also available at the Matlab File Exchange). However, if you want to work with point clouds and visualize them, or you need a more flexible and powerful ICP algorithm to align > 2 point clouds at once, this here might be the right solution for you.DocumentationThe documentation is hosted here: https://www.geo.tuwien.ac.at/pg/pctools/pctools.htmlCurrently included are:pointCloud class: a Matlab class to read, manipulate and write point cloudsglobalICP class: a Matlab class to optimize the alignment of many point clouds with the ICP algorithmAlso available on:Please cite related papers if you use this code:@article{glira2015a, title={A Correspondence Framework for ALS Strip Adjustments based on Variants of the ICP Algorithm}, author={Glira, Philipp and Pfeifer, Norbert and Briese, Christian and Ressl, Camillo}, journal={Photogrammetrie-Fernerkundung-Geoinformation}, volume={2015}, number={4}, pages={275--289}, year={2015}, publisher={E. Schweizerbart'sche Verlagsbuchhandlung}}Star History

This is the Matlab implementation of the paper:Mahmoud Afifi, "11K Hands: Gender recognition and biometric identification using a large dataset of hand images." Multimedia Tools and Applications, 2019.Please cite the following work if you use the provided source code, pre-trained models, or the dataset:Mahmoud Afifi, "11K Hands: Gender recognition and biometric identification using a large dataset of hand images." Multimedia Tools and Applications, 2019Project webpage: https://sites.google.com/view/11khands

binAveragingAveraging noisy data into binsThe Matlab function binAveraging allows clearer visualization of power spectral density estimates of turbulent velocity density by smoothing the high-frequency range. It can also be used to average data into no-overlapping bins.The present submission contains:the function binAveraging.mAn example file Example.mlxA data set PSD_velocity.mat which contains a time series of simulated turbulent velocity fluctuations

Converting acceleration to displacements recordsSummaryThe present submission introduces a simple function ASD.m that is inspired by [1] but includes also the possibility to use the double integration technique instead of the Discrete Fourier Transform (DFT) when transforming acceleration records to displacement records. The simple right-hand difference technique is also implemented as an alternative to the DFT for transforming displacement data to acceleration data.The function also includes the possibility to compute the velocity histories from the acceleration of displacement records.ContentThe submission contains three files:The function ASD.m, which is an acronym for Acceleration-Speed-Displacement.Two data file data_bridge.mat and data_beam.mat that contains the computed vertical acceleration, velocity and displacement response from a suspension bridge and a cantilever beam, respectively. The data set is created using [2]Two example files Example1.mlx and Example2.mlx, that illustrates how the function ASD.m can be called.The is the second version of the submission, Several typos may still be present as well as bugs. Any suggestion, comment or question is welcomed. Credits for the present submission should also go to ref. [1] for the function iomega.References:[1] https://www.mathworks.com/matlabcentral/answers/21700-finding-the-velocity-from-displacement#answer_33902[2] https://www.mathworks.com/matlabcentral/fileexchange/66016-response-of-a-line-like-structure-to-a-random-load

Check the Examples Tab ^^ for function descriptions, syntax, etc. This is an Antarctic Mapping Tools plugin for MEaSUREs Antarctic Boundaries for IPY 2007-2009 from Satellite Radar, Version 2 (Mouginot et al., 2017). All the data are contained in this File Exchange upload, so you don't need to download the data from the NSIDC, but you can read the full details here: http://nsidc.org/data/NSIDC-0709. This toolbox contains several functions for masking based ice basins, or groundedness. Also some plotting functions to show grounding line, coast line, or ice basins. If this toolbox is helpful for you, please cite the following: The dataset: Mouginot, J., E. Rignot, and B. Scheuchl. 2017. MEaSURES Antarctic Boundaries for IPY 2007-2009 from Satellite Radar, Version 1. [Indicate subset used]. Boulder, Colorado USA. NASA National Snow and Ice Data Center Distributed Active Archive Center. doi:http://dx.doi.org/10.5067/AXE4121732AD.Literature citation:Rignot, E., S. S. Jacobs, J. Mouginot, and B. Scheuchl. 2013. Ice-shelf melting around Antarctica, Science. 341. 266-270. http://dx.doi.org/10.1126/science.1235798. Antarctic Mapping Tools: Chad A. Greene, David E. Gwyther, and Donald D. Blankenship. Antarctic Mapping Tools for Matlab. Computers & Geosciences. 104 (2017) pp. 151-157 http://dx.doi.org/10.1016/j.cageo.2016.08.003

Check the Examples tab above for function contents, syntax, and examples ^ ^. Bedmap2 is a 1 km resolution dataset of Antarctic surface, ice thickness, and bed topography. Details about Bedmap2 can be found here:https://www.bas.ac.uk/project/bedmap-2/. This set of functions is a plugin for Antarctic Mapping Tools (Greene et al., 2017). References Fretwell, P., et al. "Bedmap2: improved ice bed, surface and thickness datasets for Antarctica." The Cryosphere 7.1 (2013). http://dx.doi.org/10.5194/tc-7-375-2013Chad A. Greene, David E. Gwyther, and Donald D. Blankenship. Antarctic Mapping Tools for Matlab. Computers & Geosciences. 104 (2017) pp. 151-157 http://dx.doi.org/10.1016/j.cageo.2016.08.003

A new meta-heuristic optimization approach, called “Sperm Swarm Optimization (SSO)” is proposed. The underlying ideas and concepts behind the proposed method are inspired by sperm motility to fertilize the egg. In SSO, sperm swarm moves forward from a low-temperature zone called Cervix. During this direction, sperm searches for a high-temperature zone called Fallopian Tubes where the egg is waiting for the swarm for fertilization in this zone, which this area is considered as the optimal solution. Note: This version of the code is without mutation part in which is a secondary thing. The full result of this algorithm in solving CEC2017 is available in (Paper:HSSOGSA). The dataset of CEC2017 is available in Dataset.Another Algorithms are in the following links:https://www.mathworks.com/matlabcentral/fileexchange/124351-chernobyl-disaster-optimizer-cdo https://www.mathworks.com/matlabcentral/fileexchange/92130-hssogsahttps://github.com/sh7adeh1990

windSimFastA three-variate turbulent wind field (u,v and w components) is simulated in three-dimensions.SummaryA turbulent wind field (u,v,w, components) in 3-D (two dimensions for space and one for the time) is simulated using random processes. The computational efficiency of the simulation relies on Ref. [1], which leads to a significantly shorter simulation time than the function windSim, also available on fileExchange. However, only the case of a regular 2D vertical grid normal to the flow is here considered.ContentThe submission contains:An example file Example1 that illustrates simply how the output variables look like.An example file Example2, which is more complete, and which simulates a 3-D turbulent wind field on a 7x7 grid.A data file exampleData.mat used in Example1.The function windSimFast.m, which is used to generate the turbulent wind field. A similar implementation of windSimFast.m was used in ref. [2].The function getSamplingpara.m, which computes the time and frequency vectors.The function KaimalModel.m, which generates the one-point auto and cross-spectral densities of the velocity fluctuations, following the Kaimal model [3]. I have corrected the cross-spectrum density formula used by Kaimal et al. so that the simulated friction velocity is equal to the target one.The function coherence used to estimate the root-mean-square coherence, the co-coherence and the quad-coherence.The function write2bts to convert the data into a .bts file (binary data). This function is still under testing and I ignore if it performs well.Any comment, suggestion or question is welcomed.References[1] Shinozuka, M., & Deodatis, G. (1991). Simulation of stochastic processes by spectral representation. Applied Mechanics Reviews, 44(4), 191-204.[2] Wang, J., Cheynet, E., Snæbjörnsson, J. Þ., & Jakobsen, J. B. (2018). Coupled aerodynamic and hydrodynamic response of a long span bridge suspended from floating towers. Journal of Wind Engineering and Industrial Aerodynamics, 177, 19-31.[3] Davenport, A. G. (1961). The spectrum of horizontal gustiness near the ground in high winds. Quarterly Journal of the Royal Meteorological Society, 87(372), 194-211.

eigenBridgeSummaryThe calculation of the eigenfrequencies and mode shapes of a suspension bridge using the present Matlab code is based on the theory of continuous beam and the theory of shallow cables. The mode shapes are obtained using Galerkin's method where a series expansion is used. The method was first applied by Sigbjörnsson & Hjorth-Hansen [1]. E. Strømmen [2] expanded their works to the vertical and torsional motion.The bridge is represented as a horizontal streamlined beam, where the z-axis is the vertical axis, the y-axis is the along-beam axis and the x-axis is the cross-beam axis. The three motions of interests (lateral, vertical, and torsional) and both symmetric and asymmetric modes are computed.Content:eigenBridge is a function that computes the mode shapes and eigenfrequencies of the suspension bridgeDocumentation.mlx: is an example of the application of this functionReferences:[1] Sigbjönsson, R., Hjorth-Hansen, E.: Along wind response of suspension bridges with special reference to stiffening by horizontal cables. Engineering Structures 3, 27-37 (1981)[2] Structural Dynamics, Einar N Strømmen, Springer International Publishing, 2013. ISBN: 3319018019, 9783319018010 Characteristics of the single-span suspension bridge

The Geometry and Image-Based Bioengineering add-On for MATLABhttp://gibboncode.org/GIBBON (The Geometry and Image-Based Bioengineering add-ON) is an open-source MATLAB toolbox by Kevin M. Moerman and includes an array of image and geometry visualization and processing tools and is interfaced with free open source software such as TetGen, for robust tetrahedral meshing, and FEBio for finite element analysis. The combination provides a highly flexible image-based modelling environment and enables advanced inverse finite element analysis.IMPORTANT cite as: K. M. Moerman, “GIBBON: The Geometry and Image-Based Bioengineering add-On,” J. Open Source Softw., vol. 3, no. 22, p. 506, Feb. 2018, doi: 10.21105/joss.00506Example sentence to cite this work: "... the mesh was created using the open source toolbox GIBBON (v3.5.0, Moerman et al. 2018, https://www.gibboncode.org)"

MATLAB code to compute the friction factor in pipes for given values of the Reynolds number (Re) and the relative roughness coefficient (epsilon).Syntax: f = colebrook(Re,epsilon)Example 1: Single Re, single epsilon Re = 1e5; epsilon = 1e-4; f = colebrook(Re,epsilon)Example 2: Multiple Re, single epsilon Re = 5000:1000:100000; epsilon = 1e-4; f = colebrook(Re,epsilon); plot(Re,f)Example 3: Single Re, multiple epsilon Re = 1e5; epsilon = linspace(1e-4,1e-1,100); f = colebrook(Re,epsilon); plot(epsilon,f)Example 4: Multiple Re, multiple epsilon Re = logspace(4,8,100); epsilon = linspace(1e-4,1e-1,100); [RE,EPSILON] = meshgrid(Re,epsilon); F = colebrook(RE,EPSILON); surf(RE,EPSILON,F)References: [1] Colebrook, C. F., & White, C. M. (1937). Experiments with fluid friction in roughened pipes. Proceedings of the Royal Society of London. Series A - Mathematical and Physical Sciences, 161(906), 367-381. [2] Colebrook, C. (1939). Turbulent Flow in Pipes, with Particular Reference to the Transition Region between the Smooth and Rough Pipe Laws. Journal of the Institution of Civil Engineers, 11(4), 133-156.

Please contact the author at sjc08@ic.ac.uk for any questions or if you wish to cite this application in a academic study.Journal paper available here: http://www.sciencedirect.com/science/article/pii/S2352711016300280User manual available here: https://sourceforge.net/projects/taufactor/files/?source=navbarTauFactor is a MatLab application for efficiently calculating the tortuosity factor, as well as volume fractions, surface areas and triple phase boundary densities, from image based microstructural data. The tortuosity factor quantifies the apparent decrease in diffusive transport resulting from convolutions of the flow paths through porous media. TauFactor calculates this value using an over relaxed finite-different approach. This tool provides a fast computational platform applicable to the big datasets (up to 4x10^9 voxels) typical of modern tomography, without requiring high computational power.

Automated Frequency Domain Decomposition (AFDD)Automated Modal parameters identification from ambient vibrations measurementSummaryThe automated Frequency Domain Decomposition presented was applied in [1]. It inspired by the Frequency Domain Decomposition (FDD) introduced by [2, 3]. The goal is to identify the mode shapes, eigenfrequencies and modal damping ratios from acceleration records obtained during structural health monitoring of civil engineering structures subjected to ambient noise. In this submission, an automated procedure is implemented in addition to the manual one proposed by [4]. For the automated procedure, I am using the peak picking function “pickpeaks” developed by [5] and available in [6], which was much more efficient than the Matlab function "findpeaks" for this purpose. I am, therefore, indebted to [4-6] for their previous works. The modal damping ratios are determined for each mode by using [7]. The acceleration data comes from a time-domain simulation of a clamped-free beam response to white noise excitation. The target modal properties from the beam come from [8].ContentThe submission contains:The function AFDDA Matlab livescript file Documentation.mlxAcceleration data beamData.m (4 Mb)The function pickpeaks.m [6]Any comment, suggestion and question is welcome.References[1] Cheynet, E., Jakobsen, J. B., & Snæbjörnsson, J. (2017). Damping estimation of large wind-sensitive structures. Procedia engineering, 199, 2047-2053.[2] Brincker, R.; Zhang, L.; Andersen, P. (2001). "Modal identification of output-only systems using frequency domain decomposition". Smart Materials and Structures 10 (3): 441. doi:10.1088/0964-1726/10/3/303.[3] Brincker, R., Zhang, L., & Andersen, P. (2000, February). Modal identification from ambient responses using frequency domain decomposition. In Proc. of the 18*‘International Modal Analysis Conference(IMAC), San Antonio, Texas.[4] https://se.mathworks.com/matlabcentral/fileexchange/50988-frequency-domain-decomposition--fdd-[5] Antoine Liutkus. Scale-Space Peak Picking. [Research Report] Inria Nancy - Grand Est (Villers-lès-Nancy, France). 2015. .[6] https://se.mathworks.com/matlabcentral/fileexchange/42927-pickpeaks-v-select-display-[7] https://se.mathworks.com/matlabcentral/fileexchange/55557-modal-parameters-identification-from-ambient-vibrations--sdof-[8] https://se.mathworks.com/matlabcentral/fileexchange/52075-eigen-value-calculation-of-a-continuous-beam--transverse-vibrations-

THIS FILE IS OUT OF DATE. The current, more efficient version is in the Climate Data Toolbox here: https://www.mathworks.com/matlabcentral/fileexchange/70338.

The optimal power flow (OPF) problem is the backbone tool for power system operation. The objective of the OPF problem is to determine the optimal operating state of a power system by optimizing a particular objective while satisfying certain operating constraints.This code is an illustration on how to solve the OPF problem using a metaheuristic.

DeepESN2019a - Deep Echo State Network Toolbox v1.1 (February 2019)** GENERAL INFORMATION **Deep Echo State Networks (DeepESN) extend the Reservoir Computing paradigm towards the Deep Learning framework. Essentially, a DeepESN is a deep Recurrent Neural Network composed of a stacked composition of multiple recurrent reservoir layers, and of a linear readout layer that computes the output of the model. The deep reservoir part is left untrained after initialization, and the readout is the only part of the architecture that undergoes a training process.All details on the DeepESN model can be found in the reference paper reported below in the CITATION REQUEST section.Also note that DeepESNs with a single layer reduce to standard Echo State Networks (ESNs), thereby the code provided in this toolbox can also be used for standard (i.e., shallow) ESN applications.The toolbox contains the files listed below.- DeepESN.m: The file contains the definition of the class DeepESN (the main class in the toolbox).- Task.m: The file contains the definition of the auxiliary class Task.- example_DeepESN_1.m: The file contains an example of the usage of the classes in the DeepESN toolbox for the short-term Memory Capacity (MC) task.- example_task_MC.m: The file contains an example of the usage of the methods in the Task class, including loading of (input and target) data from .csv files, and hold-out cross-validation settings.- MC100.mat: The file contains an object of class Task, representing the information for the MC task (up to 100 reservoir units), used in the provided example code. This file contains the Task object obtained by running example_task_MC.m- MC_input.csv, MC_target.csv: files in csv format containing the input and target data for the MC task.All the files come with full documentation, accessible through the individual reference pages, or through the help function. E.g., for info on the DeepESN class, type 'help DeepESN' in the Matlab command window.** CITATION REQUEST **The DeepESN model has been proposed in the following journal paper, which represents a citation request for the usage of this toolbox:C. Gallicchio, A. Micheli, L. Pedrelli, "Deep Reservoir Computing: A Critical Experimental Analysis", Neurocomputing, 2017, vol. 268, pp. 87-99** FURTHER READING **An up-to-date overview of the research developments on DeepESN can be found in:C. Gallicchio, A. Micheli, "Deep Echo State Network (DeepESN): A brief survey", arXiv preprint arXiv:171204323, 2018** AUTHOR INFORMATION **Claudio Gallicchiogallicch@di.unipi.it - https://sites.google.com/site/cgallicch/Department of Computer Science - University of Pisa (Italy)Computational Intelligence & Machine Learning (CIML) Grouphttp://www.di.unipi.it/groups/ciml/

dynaResp_beam_TDThe dynamic displacement response of a line-like structure to an uncorrelated Gaussian white noise input is computed in the time domain.ContentThe submission contains:the function dynaResp_TD that computes the time history of the displacement response of a line-like structure to a given load.The function eigenModes.m used here to compute the mode shapes and eigenfrequency of a cantilever beamThe file bridgeModalProperties.mat that loads the mode-shapes and eigenfrequency of a single span suspension bridge.2 example files Example1.mlx and Example2.mlxTo keep the analysis as simple as possible, the structure has only one type of motion. No modal coupling is introduced and no added mass, stiffness or damping is included.Any comments, suggestion or question is welcomed.Illustration{:height="75%" width="75%"}

MOBATSimMOBATSim (Model-based Autonomous Traffic Simulation Framework) is a simulation framework based on MATLAB® and Simulink® that provides a set of customizable models and code for simulating automated driving systems. The project's main goal is to help users/students jump-start with a baseline template that lets them run traffic simulations, which also allows them to customize/experiment with path planning, decision-making, and control algorithms. The main use case is to run automated traffic simulations using Simulink models and MATLAB scripts/functions on a default map with streets and an intersection. By defining a driving scenario, the starting and destination points of the vehicles are set as initial conditions on the map. The trajectories of the simulated vehicles can be logged to assess the safety and the performance of the tested algorithm/controller or to visualize their behaviors using supported 2D and 3D visualization options. If you would like to read more about MOBATSim and how it can be used for simulation-based testing, make sure you check our scientific paper.Table of contentsVersion and Toolbox RequirementsCitationGetting StartedVersion and Toolbox RequirementsMOBATSim is developed with Release 2020b of MATLAB® and Simulink®. There may be issues and unexpected errors with other versions. Therefore, for running MOBATSim, the requirement is R2020b version for the following MathWorks products and toolboxes:MATLAB®Simulink®Automated Driving Toolbox™Control System Toolbox™Deep Learning Toolbox™Model Predictive Control Toolbox™Robotics System Toolbox™Simulink 3D Animation™ (only required for the 3D Animation Virtual World)Stateflow®Symbolic Math Toolbox™CitationIf you use MOBATSim for scientific work please cite our related paper as:Saraoglu, M., Morozov, A., & Janschek, K. (2019). MOBATSim: MOdel-Based Autonomous Traffic Simulation Framework for Fault-Error-Failure Chain Analysis. IFAC-PapersOnLine, 52(8), 239–244. Elsevier BV. Retrieved from https://doi.org/10.1016%2Fj.ifacol.2019.08.077BibTex:@article{MOBATSim, title = {{MOBATSim}: {MOdel}-Based Autonomous Traffic Simulation Framework for Fault-Error-Failure Chain Analysis}, journal = "IFAC-PapersOnLine", volume = "52", number = "8", pages = "239 - 244", year = "2019", note = "10th IFAC Symposium on Intelligent Autonomous Vehicles IAV 2019", issn = "2405-8963", doi = "https://doi.org/10.1016/j.ifacol.2019.08.077", url = "http://www.sciencedirect.com/science/article/pii/S2405896319304100", author = "Mustafa Saraoglu and Andrey Morozov and Klaus Janschek", keywords = "Autonomous driving, Fault injection, Error propagation, Safety analysis, Traffic simulator", }We would like to acknowledge the help and support in the development of MOBATSim of the following contributors: Sheng Ding, Manuel Schirmer, Johannes Pintscher, Laura Slabon, Qianwei Yang, Qihang Shi, Wenkai Wu, Maoxuan Zhao, Erik Noack, Fabian Hart, Müjdat Korkmaz, Marta Valdes Martin, Mustafa SaraoğluGetting StartedMOBATSim has a project file that includes the Simulink files and their paths. The project can be opened by double-clicking on MOBATSim.prj and a GUI will appear, which can be used to start the simulation. Simply click on Start Simulation and wait for the simulation to start.After opening the MOBATSim folder please refer to the live script file GettingStarted.mlx for more detailed documentation.Key Features of MOBATSimMost of the scripts, class files, and functions used in MOBATSim can be edited to control the vehicles, intersection management algorithm, and the map's road network.Each vehicle is considered as an agent, and the traffic is simulated as a closed-loop multi-agent system. The vehicles generate their trajectories during the simulation according to the states and intentions of the other vehicles around in the environment.Users can either develop an algorithm or a controller for a single vehicle (usually referred to as the ego vehicle) or different implementations for different vehicles simultaneously.Full control over all the internal states of the vehicles during simulation allows for fault injection and error propagation analysis. The states and the signals can be easily manipulated by implementing some Simulink fault injection blocks or inserting some code snippets in MATLAB System Block functions.The results can be used for benchmarking control and decision algorithms regarding safety, robustness and performance on different abstraction levels such as component level, vehicle level, and traffic level.Object-oriented programming structure (MATLAB Classes) combined with a block diagram environment (Simulink) allows for a flexible framework.The vehicles and the map are shown on a 2D plot during the simulation. After a single simulation, the data logged in Simulink can be used for various post-simulation visualization options (e.g., Driving Scenario Designer App, Bird's-Eye View Scope, or Simulink 3D Animation).Known Issues and BugsVehicles are not allowed to choose any node inside or around the intersection as starting or destination points.Some road merges do not have safety guarantees which means that collisions may happen if two vehicles join at the same time.Changing the default sample time value of 0.02 or playing with different Simulink Solver options other than auto may cause unexpected behavior.

Colored Noise Matlab toolbox to generate power-law colored noise signals of any dimensions.AuthorAbhranil Das, Center for Perceptual Systems, The University of Texas at Austin.Bugs/comments/questions/suggestions to abhranil.das@utexas.edu.If you use this code, please cite: Camouflage Detection & Signal Discrimination: Theory, Methods & Experiments.InstallationWithin Matlab's Home tab, select Add-Ons > Get Add-Ons > Search for 'Colored Noise' and install.Quick StartAfter installation, begin with the Getting Started live script with interactive examples, or, at any time, go to Matlab Home tab > Add-Ons > Manage Add-Ons > click the three dots next to this toolbox > View Getting Started GuideDocumentationType:doc colored_noise

FieldTrip is the MATLAB software toolbox for MEG and EEG analysis that is being developed by a team of researchers at the Donders Institute for Brain, Cognition and Behaviour in Nijmegen, the Netherlands in close collaboration with collaborating institutes.FieldTrip offers advanced analysis methods of MEG, EEG, and invasive electrophysiological data, such as time-frequency analysis, source reconstruction using dipoles, distributed sources and beamformers and non-parametric statistical testing. It supports the data formats of all major MEG systems (CTF, Elekta/Neuromag, 4D, Yokogawa) and of most popular EEG systems, and new formats can be added easily. FieldTrip contains high-level functions that you can use to construct your own analysis protocols in MATLAB. Furthermore, it easily allows developers to incorporate low-level algorithms for new EEG/MEG analysis methods.Furthermore, it offers a frequently updated website [1] with tutorials, example data and other documentation. There is an active community centered around the email discussion list [2].FieldTrip is the mostly used software for MEG data analysis and developed in close collaboration with related open source projects, such as EEGLAB, SPM, BrainStorm and MNE.Please cite the FieldTrip reference paper [3] when you have used FieldTrip for data analysis in your study.[1] http://www.fieldtriptoolbox.org[2] http://www.fieldtriptoolbox.org/discussion_list[3] http://dx.doi.org/10.1155/2011/156869

This AC/DC HMG has two AC voltage distribution levels (the primary level is 13,8 kV and the secondary level is 220 V) and one DC distribution level (300V). The AC MG operates at a frequency of 60 Hz.This test system simulation includes:• One diesel generator,• Two photovoltaic (PV) systems,• Two battery energy storage system,• Various linear and non-linear loads.Additionally, the DC microgrid model is extracted from the original model.

zombieInfectionModellingMatlab code for the simulation of a zombie outbreakSummaryIn 2009, Munz et al. [1] have written a pedagogical paper that helps to understand how to solve systems of coupled differential equations. it dealt with the simulation of zombie infection among the human population. The model is here implemented in Matlab using a slightly different approach than by [1].ContentThe present repository is made of:one example fileone zombies.m function that implements (partly) the model proposed by Munz et al.one erad.m function that is based on the "impulsive eradication" model.References[1] Munz, Philip, et al. "When zombies attack!: mathematical modelling of an outbreak of zombie infection." Infectious Disease Modelling Research Progress 4 (2009): 133-150

GeographicLib toolboxVersion 2.3.1 2024-08-27Native Octave/MATLAB implementations of a subset of the C++ library, GeographicLib. Key components of this toolbox are:Geodesics, direct, inverse, area calculations.Projections, transverse Mercator, polar stereographic, etc.Grid systems, UTM, UPS, MGRS.Geoid lookup, egm84, egm96, egm2008 geoids supported.Geometric transformations, geocentric, local cartesian.Great ellipse, direct, inverse, area calculations.Geodesics and coordinate conversions on a triaxial ellipsoid.(The last two items are not present in the C++ library.) All the functions are vectorized and so offer speeds comparable to compiled C++ code when operating on arrays.Full documentation is available on github. This page gives more details on the routines for triaxial ellipsoids.

The multiobjective cuckoo search (MOCS) is a nature-inspired optimization algorithm. This demo solves the bi-objective ZDT3 functions with D=30 (dimensions), and the obtained Pareto Front is displayed. It is relatively straightforward to extend this code to solve other multi-objective functions and optimization problems. You can change the objective functions, dimensionality, various parameters, and simple lower and upper bounds (Lb, Ub).

This is a detailed Matlab implementation of five classic inpainting methods (AMLE, Harmonic, Mumford-Shah, Cahn-Hilliard, Transport) described in "Partial Differential Equation Methods for Image Inpainting" (Carola-Bibiane Schönlieb, Cambridge University Press, 2015).

Functions include:aer2ecef aer2enu aer2geodetic aer2nedecef2aer ecef2enu ecef2enuv ecef2geodetic ecef2ned ecef2nedvenu2aer enu2ecef enu2geodeticgeodetic2aer geodetic2ecef geodetic2enu geodetic2nedned2aer ned2ecef ned2geodeticlookAtSpheroid

A VST 2 audio effect plugin written in MATLAB that uses a genetic algorithm to generate a random impulse response describing the reverberation of an artificial room, and uses the impulse response to apply convolution reverb to a signal in real-time. A MATLAB script version (main.m) is also available, which accepts a WAV audio file as input instead. The input is combined with the impulse response via convolution, applying the reverb effect to the pre-recorded audio.Since no two impulse responses will ever be the same, both the script and the plugin are also able to save the generated impulse responses to new files as well. You can then load the generated impulse response files into other programs such as my simple IR Reverb Pure Data patch (https://github.com/edward-ly/reverb-pd) or the Convolution Reverb device in Ableton Live (https://www.ableton.com/en/packs/convolution-reverb/) to perform the same reverb effect.A video explaining and demonstrating (an older version of) the plugin is below:https://www.youtube.com/watch?v=Ef1d6nr7TqEThis plugin was selected as a finalist in the MATLAB Plugin Student Competition at the 147th AES Convention in New York, 2019, then later published in the Special Issue "Artificial Intelligence and Complexity in Art, Music, Games and Design" of the journal "Entropy".For details regarding generating and running the plugin as well as an explanation of the user parameters in the plugin, see the included README.md file.

% Please run this demo file to generate three different types of surfaces% (1) Fracal surface% (2) Sinusoidal surface% (3) Random surface % If you find this toolbox useful, please cite the following papers:% [1]Y. Chen and H. Yang, Numerical simulation and pattern characterization of% nonlinear spatiotemporal dynamics on fractal surfaces for the whole-heart modeling% applications, European Physical Journal, DOI: 10.1140/epjb/e2016-60960-6% [2]B. Yao, F. Imani, A. Sakpal, E. W. Reutzel, and H. Yang*, “Multifractal % analysis of image profiles for the characterization and detection of defects % in additive manufacturing,” ASME Journal of Manufacturing Science and Engineering, % Vol. 140, No. 3, p031014-13, 2017, DOI: 10.1115/1.4037891% [3]F. Imani, B. Yao, R. Chen, P. Rao, and H. Yang*, “Joint multifractal % and lacunarity analysis of image profiles for manufacturing quality control”. % ASME Journal Manufacturing Science and Engineering, Vol. 141, No. 4, % p 044501-7, 2019. DOI: 10.1115/1.4042579

## Read me[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/acpennlab/statistics-resampling-online/jammy-docker?urlpath=/lab/tree/statistics-resampling.ipynb) [![Documentation](https://img.shields.io/badge/docs-online-blue.svg)](https://gnu-octave.github.io/statistics-resampling/) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3992392.svg)](https://doi.org/10.5281/zenodo.3992392) [![GitHub](https://img.shields.io/github/stars/gnu-octave/statistics-resampling?label=GitHub%20Repo&style=social)](https://github.com/gnu-octave/statistics-resampling/)### Package maintainerAndrew Penn (andy.c.penn@gmail.com)### Package contributorsAndrew Penn (More contributors are welcome!)### CitationsIf you use this package, please include the following citation(s):* Penn, Andrew Charles. (2020). Resampling methods for small samples or samples with complex dependence structures. *Zenodo*. [https://doi.org/10.5281/zenodo.3992392](https://doi.org/10.5281/zenodo.3992392) [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3992392.svg)](https://doi.org/10.5281/zenodo.3992392)(Note that package versions 5.4.3 and below were named the 'statistics-bootstrap' package. The 'statistics-resampling' package is a more developed version of the older ['iboot'](https://github.com/acp29/iboot) package). ### DescriptionThe statistics-resampling package is an Octave package and Matlab toolbox that can be used to perform a wide variety of statistics tasks using non-parametric resampling methods. In particular, the functions included can be used to estimate bias, uncertainty (standard errors and confidence intervals), prediction error, information criteria, and calculate *p*-values for null hypothesis significance tests. Variations of the resampling methods are included that improve the accuracy of the statistics for small samples and samples with complex dependence structures. ### Using the statistics-resampling package online Try out the statistics-resampling package in your browser at [statistics-resampling-online](https://mybinder.org/v2/gh/acpennlab/statistics-resampling-online/jammy-docker?urlpath=/lab/tree/statistics-resampling.ipynb) [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/acpennlab/statistics-resampling-online/jammy-docker?urlpath=/lab/tree/statistics-resampling.ipynb): a ready-to-go implementation of statistics-resampling in a JupyterLab Notebook with an Octave kernel. *Note that the first time (since the last repository commit) that you use statistics-resampling online with Binder you can expect it to take a while to build a docker image, but subsequent access to statistics-resampling-online will take less than a minute or so.*Collaborative student projects in GNU Octave can use the statistics-resampling package at [Octave-Online](https://octave-online.net/). Doing so requires users to download the latest release of the Source code (tar.gz) from [here](https://github.com/gnu-octave/statistics-resampling/releases) and follow steps 2-5 of these [instructions](https://octaveonline.uservoice.com/knowledgebase/articles/1078840-installing-custom-packages).Users who prefer Jupyter and have a workflow that is collaborative and/or crosses over multiple programming languages may find it more convenient to install and use the statistics-resampling package at [COCALC](https://cocalc.com/). The approach described above (for Octave-Online) also applies to installing the statistics-resampling package via a Jupyter Notebook with an Octave kernel at COCALC. Alternatively, if you have an account with MATLAB you can try out the statistics-resampling package at [Matlab-Online](https://matlab.mathworks.com/open/github/v1?repo=gnu-octave/statistics-resampling&file=README.md) [![Open in MATLAB Online](https://www.mathworks.com/images/responsive/global/open-in-matlab-online.svg)](https://matlab.mathworks.com/open/github/v1?repo=gnu-octave/statistics-resampling&file=README.md) by either following the local installation instructions below, or by adding the *toolbox* (not collection) version of the package via Apps >> Get More Apps. Follow the links in the 'Quick start' section below to obtain some examples of data and code to try out with the package. ### Requirements and dependencies Users with greater computational demands may want to consider installing and running the statistics-resampling package offline. Installation of the statistics-resampling package has some software requirements. The core functions in this package require, and are known to be compatible with, [GNU Octave](https://octave.org/) (version >= 4.4.0) and [Matlab](https://uk.mathworks.com/products/matlab.html) (version >= R2007a 7.4.0). Some optional features of this package have further dependencies: * All parallel computing options require either the [parallel package](https://gnu-octave.github.io/packages/parallel/) (in Octave) or the [Parallel Computing Matlab Toolbox](https://uk.mathworks.com/products/parallel-computing.html) (in Matlab). Note that the Parallel package in Octave also requires the [struct package](https://gnu-octave.github.io/packages/struct/). * The optional jackknife functionality in `boot1way` requires the [statistics package](https://gnu-octave.github.io/packages/statistics/) (in Octave) or the [Statistics and Machine Learning Toolbox](https://uk.mathworks.com/products/statistics.html) (in Matlab). ### Installation To install (or test) the statistics-resampling package in your computer at a location of your choice, for either **Matlab or Octave**, follow these steps: * Download the latest package release from [here](https://github.com/gnu-octave/statistics-resampling/releases/). Extract (not just browse) the contents of the compressed file (.zip or .tar.gz), and move the package directory to the desired location. * Open Octave or Matlab (command prompt). * Change directory (cd) into the package folder. (The directory contains a file called 'make.m' and 'install.m', among others) * Type `make` to compile the MEX files from source (or use the precompiled binaries if available. If suitable precompiled binaries are not available for your platform, then Matlab/Octave will need access to a C++11 compiler. Note that if you skip the make step, then the package functions will still work, but some will run slower. This step is interactive so check the command window.) * Type `install`. The package will load now (and automatically in the future) when you start Octave/Matlab. If you want or need to uninstall the package, change directory (cd) into the package folder and type uninstall. Alternatively, **Octave** users can install the latest release of the package just like any other Octave package by typing: `pkg install -forge statistics-resampling` Or for the most recent developmental version of the package: `pkg install "https://github.com/gnu-octave/statistics-resampling/archive/refs/heads/master.zip"` The package can then be loaded on demand in Octave with the following commmand: `pkg load statistics-resampling` (Note that this isn't necessary if you used the local installation instructions first described in this section) Alternatively, **MATLAB** users can conveniently install the package functions as a toolbox by double-clicking the 'statistics-resampling.mltbx' file in the matlab subdirectory. The toolbox installed in this way can be disabled or uninstalled via MATLAB's Add-On manager. MEX files are included with the toolbox installation for Windows (32- or 64-bit), MacOS (Intel or Apple Silicon 64-bit) and Linux (64-bit). ### UsageAll help and demos are documented on the ['Function Reference'](https://gnu-octave.github.io/statistics-resampling/function_reference) page in the [manual](https://gnu-octave.github.io/statistics-resampling/). If you do not see the navigation pane on the manual web pages, please enable javascript in your browser. If you need further help with using any of the functions in this package, please post your questions on the [discussions page](https://github.com/gnu-octave/statistics-resampling/discussions). Function help can also be requested directly from the Octave/MATLAB command prompt, by typing `help function-name` - substituting in the actual function name. In Octave only, you can get a basic overview of the package and it's functions by typing: `pkg describe -verbose statistics-resampling`, or request demonstrations of function usage by typing `demo function-name`. Users can also request help with using functions and programming in Octave at the [discourse group](https://octave.discourse.group/c/help/6). *TIPS: You can now document and publish your statistics-resampling analysis in Jupyter Notebooks (with an Octave kernel) at your GitHub repository using the [nbgitpuller link generator](https://nbgitpuller.readthedocs.io/en/latest/link.html?tab=binder) and the statistics-resampling-online Binder environment [![](https://img.shields.io/github/stars/acpennlab/statistics-resampling-online?label=GitHub%20Repo&style=social)](https://github.com/acpennlab/statistics-resampling-online/). Alternatively, you could fork the repository or use it as a template for you own GitHub repository. Using Jupyter notebooks, you can also integrate use of the statistics-resampling package into your analysis workflow alongside other programming languages including Python, R and Julia [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/acpennlab/statistics-resampling-online/jammy-docker?urlpath=/lab/tree/statistics-resampling.ipynb)* ### Quick startBelow are links to demonstrations of how the bootstrap or randomization functions from this package can be used to perform variants of some commonly used statistical tests, but without the Normality assumption: * [t-test to compare two independent samples (assuming equal variances)](https://gnu-octave.github.io/statistics-resampling/function/boot1way.html#1) * [t-test to compare two independent samples (assuming equal variances)](https://gnu-octave.github.io/statistics-resampling/function/boot1way.html#2) (but also robust to outliers) * [t-test to compare two independent samples](https://gnu-octave.github.io/statistics-resampling/function/bootlm.html#1) (but also robust to heteroscedasticity, i.e. unequal variance) * Nested t-test to compare two independent samples. (See example listed below for nested one-way ANOVA) * [t-test to compare two paired or matching samples](https://gnu-octave.github.io/statistics-resampling/function/bootlm.html#2) * [One-way ANOVA to compare two or more independent samples](https://gnu-octave.github.io/statistics-resampling/function/bootlm.html#3) (but also robust to heteroscedasticity) * [Nested one-way ANOVA to compare two or more independent samples](https://gnu-octave.github.io/statistics-resampling/function/bootlm.html#13) (but also robust to heteroscedasticity and grouping of observations) * [Balanced two-way factorial ANOVA](https://gnu-octave.github.io/statistics-resampling/function/bootlm.html#6) (but also robust to heteroscedasticity) * [Unbalanced two-way factorial ANOVA](https://gnu-octave.github.io/statistics-resampling/function/bootlm.html#7) (but also robust to heteroscedasticity) * [Simple linear regression](https://gnu-octave.github.io/statistics-resampling/function/bootlm.html#8) (but also robust to heteroscedasticity) * [One-way ANCOVA](https://gnu-octave.github.io/statistics-resampling/function/bootlm.html#9) (but also robust to heteroscedasticity) * [One-way repeated measures ANOVA](https://gnu-octave.github.io/statistics-resampling/function/bootlm.html#4) * [Randomization or permutation test to evaluate whether a sample comes from a population with the specified mean](https://gnu-octave.github.io/statistics-resampling/function/randtest1.html#1) * [Randomization or permutation test to compare the distributions of two independent or paired/matching samples](https://gnu-octave.github.io/statistics-resampling/function/randtest2.html#1) * [Randomization or permutation test to compare the distributions of two independent samples with clustered observations](https://gnu-octave.github.io/statistics-resampling/function/randtest2.html#5) * [Randomization or permutation test to evaluate the statistical significance of a correlation coefficient](https://gnu-octave.github.io/statistics-resampling/function/randtest.html#3) * [Statistically evaluate the number of modes (i.e. peaks) in a distribution](https://gnu-octave.github.io/statistics-resampling/function/bootmode.html#1) * [Correcting sample size calculations for a two-sample test with nested design](https://gnu-octave.github.io/statistics-resampling/function/sampszcalc.html#6) * [Comparing linear models using bootstrap estimates of prediction error, information criteria and relative likelihood](https://gnu-octave.github.io/statistics-resampling/function/bootlm.html#15) For examples of how to import data sets from a human-readable text file, like a tab-separated-value (TSV) and comma-separated-value (CSV) file, see the examples in the JupyterLab Notebook at [statistics-resampling-online](https://mybinder.org/v2/gh/acpennlab/statistics-resampling-online/jammy-docker?urlpath=/lab/tree/statistics-resampling.ipynb) [![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/acpennlab/statistics-resampling-online/jammy-docker?urlpath=/lab/tree/statistics-resampling.ipynb) and the last demonstration listed on [this page](https://gnu-octave.github.io/statistics-resampling/function/randtest2.html#5) ### IssuesIf you find bugs or have any suggestions, please raise an issue on GitHub [here](https://github.com/gnu-octave/statistics-resampling/issues). If you have any problems specifically with Binder for statistics-resampling online, please raise an issue on GitHub [here](https://github.com/acpennlab/statistics-resampling-online/issues). Please make sure that, when reporting a bug, you provide as much information as possible for other users to be able to replicate it. Package: [statistics-resampling](https://gnu-octave.github.io/statistics-resampling/)

MathWorks provides built-in Model Comparison capabilities for reporting the differences between versions of a Simulink model. Unfortunately, MathWorks provides no commands to be able to easily and programmatically query or parse these results from the command line or a script. The Model Comparison Utility provides many functions that facilitate useful operations on the comparison, such as: finding specific types of changes, getting model handles for comparison elements, plotting the comparison as a graph, and many more.• For instructions on installation and how to use the tool, please see the included user guide: Model-Comparison-Utility/doc/ModelComparisonUtility_UserGuide.pdf.• This tool relies on our Simulink Utility. Please download it here: https://github.com/McSCert/Simulink-Utility.

Wind turbulence generation using text-based input filesFor a more robust and time-efficient Matlab implementation, see https://se.mathworks.com/matlabcentral/fileexchange/68632-wind-field-simulation-the-fast-version.SummaryA method to simulate spatially correlated turbulent wind histories is implemented following [1,2].Two possible vertical wind profiles and two possible wind spectra are implemented. The user is free to implement new ones. The wind co-coherence is a simple exponential decay as done by Davenport [3]. If the wind field is simulated in a grid, the function windSim.m should be used (cf. Examples 1 and 2). For a more complex geometry, such as a radial grid, the function windSim.m has an optional parameter to include two inputs (cf. Example3.mlx): The first one contains the wind properties, and the second one contains the coordinates of the nodes where wind histories are simulated (cf. Example 3).ContentThe folder windSim.zip contains:1 input file INPUT.txt for Example1.m1 input file INPUT_MAST.txt for Example2.m2 input files windData.txt and circle.txt for Example3.mThe function windSim.m4 examples files Example1.m, Example2.m, Example3.m and Example4.mThe function coherence.m that computes the co-coherence.Notes:Simulating the wind field in a high number of points with a high sampling frequency may take a lot of time.This code aims to be highly customizableA faster version of the present submission has been used to simulate the turbulent wind load on a floating suspension bridge [4].References[1] Shinozuka, M., Monte Carlo solution of structural dynamics, Computers and Structures, Vol. 2, 1972, pp. 855 – 874[2] Deodatis, G., Simulation of ergodic multivariate stochastic processes, Journal of Engineering Mechanics, ASCE, Vol. 122 No. 8, 1996, pp. 778 – 787.[3] Davenport, A. G. (1961), The spectrum of horizontal gustiness near the ground in high winds. Q.J.R. Meteorol. Soc., 87: 194–211[4] Wang, J., Cheynet, E., Snæbjörnsson, J. Þ., & Jakobsen, J. B. (2018). Coupled aerodynamic and hydrodynamic response of a long span bridge suspended from floating towers. Journal of Wind Engineering and Industrial Aerodynamics, 177, 19-31.

The smart phone is used as webcam device. We can use it by installing IP Webcam app. Make sure that the Laptop and your smart phone must me connected to the same network using Wifi.A specific solution for Android:Install the free IP Webcam app. (Make sure you read the corresponding permissions and understand any security issues therein)Open the app, set the desired resolution (will impact the speed!)Scroll to the bottom and tap on 'Start Server'

Eigen-value calculation of continuous beamsSummaryThe eigenfrequencies and mode shapes of a simple beam are calculated based on [1]. During the calculation procedure, It is assumed that:There is no structural coupling between the different degrees of freedom of the beamThe beam is homogeneousThe beam is un-dampedthere are free oscillationsFour boundaries conditions are included:pinned-pinnedclamped-freeclamped-clampedclamped-pinnedTwo Geometries are available:rectangular beamcylinderContent:eigenModes.m: a function used to compute the eigenfrequencies and modes shapes of a continuous beam with different boundaries conditions.Example.m is an application of this function.References[1] Engineering vibration, Daniel J. Inman (3rd edition), near page 500

If you use it for academic purposes please cite : 1. "Estimating Curvatures and Their Derivatives on Triangle Meshes" by Szymon Rusinkiewicz (2004)2. Y. Ben Shabat, A. Fischer, "Design of Adaptive Porous Micro-structures using curvature analysis for Additive Manufacturing" the 25th CIRP Design conference. 2015, Haifa, Israel.This code was implemented according to [1]. GetCurvatures computes the curvature tensor and the principal curvatures at%each vertex of a mesh given in a face vertex data structure%INPUT: -FV -struct - Triangle mesh face vertex data structure (containing FV.face andFV.Vertices) -toggleDerivatives - scalar 1 or 0 indicating whether or not to calculate curvature derivatives%OUTPUT:-PrincipalCurvatures - 2XN matrix (where N is the number of vertices containing the principal curvatures k1 and k2 at each vertex-PrincipalDir1 - NX3 matrix containing the direction of the k1 principalcurvature.-PrincipalDir2 - NX3 matrix containing the direction of the k2 principal curvature.-FaceCMatrix - 4XM matrix (where M is the number of faces) containing the 4%coefficients of the curvature tensr of each faceVertexCMatrix- 4XN matrix (where M is the number of faces) containing the 4 coefficients of the curvature tensor of each tensor.-Cmagnitude - NX1 matrix containing the square sum of the curvature tensor coefficients at each vertex (invariant scalar indicating the change of curvature)

DGTtool for computing STFT/DGTA simple and user-friendly MATLAB tool for computing the short-time Fourier transform (STFT) and the discrete Gabor transform (DGT). It is designed to be easy and fast for practical use.The following features of DGTtool might be different from the other tools:Parameters are stored inside DGTtool object for user-friendliness.All pre-computation runs only once so that repeated computation of DGT/STFT is fast.Many computations run in parallel for all channels (for multi-channel signal).Perfect reconstruction is very easily realized.Number of frequency bins can be smaller than the window length.Dual and tight windows can be computed easily.Sparse time-frequency representation (reassigned spectrogram) is implemented.Phase visualization tool (plotPhase) is implemented.STFT/DGT can be written in an operator form.How to UseDownload DGTtool.m and place it in the Current Folder.1. Create DGTtool objectCreate a DGTtool object F by specifying its parameters.F = DGTtool('windowShift',500,'windowLength',1500,'FFTnum',2000,'windowName','Blackman')(Note: This step can be done without parameters: F = DGTtool. Unspecified parameters are set to default values.)2. Compute spectrogramCompute a spectrogram X from a signal x.X = F(x);3. Convert spectrogram back to signalCompute the signal x from its spectrogram X.x = F.pinv(X);4. Visualize spectrogramThree visualization functions are implemented. A spectrogram is computed and plotted from a time-domain signal x (and sampling frequency fs, optional).F.plot(x,fs)F.plotPhase(x,fs)F.plotReassign(x,fs)DocumentationTo check all functions in DGTtool, please read and run demo.m.help DGTtoolanddoc DGTtoolprovide detailed usage.

One-point random process generationMinimalist Matlab implementation of a random process generation in one pointSummaryA stationary Gaussian random process is generated using the spectral method. This means that the function requires only two inputs: the target power spectral density (PSD) and the associated frequency vector.ContentThe present submission contains:The function randomProcess.m, which generates the (random) time series associated with a target PSDAn example file Documentation.mlx, which illustrates the generation of the random process using the case of atmospheric turbulenceThe function getSamplingPara.m, which computes the target frequency vector and the associated time vector.Any question, suggestion or comment is welcome.Example