Merge pull request SciML#260 from sathvikbhagavan/sb/joss

docs: add joss paper

joss/paper.bib

@@ -0,0 +1,114 @@
+@article{Bezanson2017,
+  author = {Bezanson, Jeff and Edelman, Alan and Karpinski, Stefan and Shah, Viral B.},
+  title = {{J}ulia: A Fresh Approach to Numerical Computing},
+  journal = {SIAM Review},
+  volume = {59},
+  number = {1},
+  pages = {65-98},
+  year = {2017},
+  doi = {10.1137/141000671},
+  URL = {https://doi.org/10.1137/141000671},
+  eprint = {https://doi.org/10.1137/141000671},
+  abstract = { Bridging cultures that have often been distant, Julia combines expertise from the diverse fields of computer science and computational science to create a new approach to numerical computing. Julia is designed to be easy and fast and questions notions generally held to be “laws of nature" by practitioners of numerical computing: \beginlist \item High-level dynamic programs have to be slow. \item One must prototype in one language and then rewrite in another language for speed or deployment. \item There are parts of a system appropriate for the programmer, and other parts that are best left untouched as they have been built by the experts. \endlist We introduce the Julia programming language and its design---a dance between specialization and abstraction. Specialization allows for custom treatment. Multiple dispatch, a technique from computer science, picks the right algorithm for the right circumstance. Abstraction, which is what good computation is really about, recognizes what remains the same after differences are stripped away. Abstractions in mathematics are captured as code through another technique from computer science, generic programming. Julia shows that one can achieve machine performance without sacrificing human convenience. }
+}
+
+@article{gowda2021high,
+  title={High-performance symbolic-numerics via multiple dispatch},
+  author={Gowda, Shashi and Ma, Yingbo and Cheli, Alessandro and Gwozdz, Maja and Shah, Viral B and Edelman, Alan and Rackauckas, Christopher},
+  journal={arXiv preprint arXiv:2105.03949},
+  year={2021}
+}
+
+@misc{ma2021modelingtoolkit,
+  title={ModelingToolkit: A Composable Graph Transformation System For Equation-Based Modeling},
+  author={Yingbo Ma and Shashi Gowda and Ranjan Anantharaman and Chris Laughman and Viral Shah and Chris Rackauckas},
+  year={2021},
+  eprint={2103.05244},
+  archivePrefix={arXiv},
+  primaryClass={cs.MS}
+}
+
+@article{Tikhonov1943OnTS,
+  title={On the stability of inverse problems},
+  author={A. N. Tikhonov},
+  journal={Proceedings of the USSR Academy of Sciences},
+  year={1943},
+  volume={39},
+  pages={195-198},
+  url={https://api.semanticscholar.org/CorpusID:202866372}
+}
+
+@article{Petters2021-aa,
+  title     = "Revisiting matrix-based inversion of scanning mobility particle
+               sizer ({SMPS}) and humidified tandem differential mobility
+               analyzer ({HTDMA}) data",
+  author    = "Petters, Markus D",
+  journal   = "Atmos. Meas. Tech.",
+  publisher = "Copernicus GmbH",
+  volume    =  14,
+  number    =  12,
+  pages     = "7909--7928",
+  month     =  dec,
+  year      =  2021,
+  copyright = "https://creativecommons.org/licenses/by/4.0/",
+  language  = "en"
+}
+
+@article{Curry1966OnPF,
+  title={On P{\'o}lya frequency functions IV: The fundamental spline functions and their limits},
+  author={Haskell B. Curry and I. J. Schoenberg},
+  journal={Journal d’Analyse Math{\'e}matique},
+  year={1966},
+  volume={17},
+  pages={71-107},
+  url={https://api.semanticscholar.org/CorpusID:120740205}
+}
+
+@article{DEBOOR197250,
+  title = {On calculating with B-splines},
+  journal = {Journal of Approximation Theory},
+  volume = {6},
+  number = {1},
+  pages = {50-62},
+  year = {1972},
+  issn = {0021-9045},
+  doi = {https://doi.org/10.1016/0021-9045(72)90080-9},
+  url = {https://www.sciencedirect.com/science/article/pii/0021904572900809},
+  author = {Carl {de Boor}}
+}
+
+@article{10.1145/321607.321609,
+  author = {Akima, Hiroshi},
+  title = {A New Method of Interpolation and Smooth Curve Fitting Based on Local Procedures},
+  year = {1970},
+  issue_date = {Oct. 1970},
+  publisher = {Association for Computing Machinery},
+  address = {New York, NY, USA},
+  volume = {17},
+  number = {4},
+  issn = {0004-5411},
+  url = {https://doi.org/10.1145/321607.321609},
+  doi = {10.1145/321607.321609},
+  abstract = {A new mathematical method is developed for interpolation from a given set of data points in a plane and for fitting a smooth curve to the points. This method is devised in such a way that the resultant curve will pass through the given points and will appear smooth and natural. It is based on a piecewise function composed of a set of polynomials, each of degree three, at most, and applicable to successive intervals of the given points. In this method, the slope of the curve is determined at each given point locally, and each polynomial representing a portion of the curve between a pair of given points is determined by the coordinates of and the slopes at the points. Comparison indicates that the curve obtained by this new method is closer to a manually drawn curve than those drawn by other mathematical methods.},
+  journal = {J. ACM},
+  month = {oct},
+  pages = {589–602},
+  numpages = {14}
+}
+
+@article{Schoenberg1946ContributionsTT,
+  title={Contributions to the problem of approximation of equidistant data by analytic functions. Part A. On the problem of smoothing or graduation. A first class of analytic approximation formulae},
+  author={I. J. Schoenberg},
+  journal={Quarterly of Applied Mathematics},
+  year={1946},
+  volume={4},
+  pages={45-99},
+  url={https://api.semanticscholar.org/CorpusID:125923957}
+}
+
+@misc{lagrange,
+  title={Lectures on Elementary Mathematics},
+  author={Lagrange, J. L, and Thomas J McCormack},
+  year={1898},
+  url={https://lccn.loc.gov/98000373},
+}

joss/paper.md

@@ -0,0 +1,64 @@
+---
+title: 'DataInterpolations.jl: Fast Interpolations of 1D data'
+tags:
+  - julia
+  - interpolations
+authors:
+  - name: Sathvik Bhagavan
+    orcid: 0000-0003-0785-3586
+    corresponding: true
+    affiliation: 1
+  - name: Christopher Rackauckas
+    orcid: 0000-0001-5850-0663
+    affiliation: "1, 2, 3"
+  - name: Shubham Maddhashiya
+    affiliation: 3
+affiliations:
+ - name: JuliaHub
+   index: 1
+ - name: Massachusetts Institute of Technology
+   index: 2
+ - name: Pumas-AI
+   index: 3
+date: 6 June 2024
+bibliography: paper.bib
+---
+
+# Summary
+
+Interpolations are used to estimate values between known data points using an approximate continuous function.DataInterpolations.jl is a Julia [@Bezanson2017] package containing 1D implementations of some of the most commonly used interpolation functions. These include Constant Interpolation, Linear Interpolation, Quadratic Interpolation, Lagrange Interpolation [@lagrange], Quadratic Splines, Cubic Splines [@Schoenberg1946ContributionsTT], Akima Splines [@10.1145/321607.321609], B-Splines [@Curry1966OnPF] [@DEBOOR197250] and Regression based B-Splines. Along with these, the package also has methods to fit parameterized curves with the data points and Tikhonov regularization [@Tikhonov1943OnTS] [@Petters2021-aa] for obtaining smooth curves. The package also provides functionality to compute integrals and derivatives upto second order for those interpolations methods.
+
+# Statement of need
+
+Interpolations are a very important component of many modeling workflows. In many models, inputs which are sampled or measured need to be represented as a continuous function or a smooth curve for simulation. In many scientific machine learning workflows, we need interpolations of data to learn continuous models. There already have been a few interpolation packages in Julia like Interpolations.jl but it has a limitation of assuming uniformly spaced data which is not usually the case with data collected from real world. DataInterpolations.jl provides fast interpolation methods for arbitrary spaced 1D data with a consistent and simple interface. It is also automatic differentiation friendly. It can also be used symbolically with Symbolics.jl [@gowda2021high] and plugged into models defined using ModelingToolkit.jl [@ma2021modelingtoolkit].
+
+# Example
+
+The following tutorials in the documentation [1](https://docs.sciml.ai/DataInterpolations/stable/methods/) provides how to define each of the interpolation methods and compute the value at any point. [2](https://docs.sciml.ai/DataInterpolations/stable/interface/) provides explanation for using the interface and interpolated objects for evaluating at any point, computing the derivative at any point and computing the integral between any two points.
+
+A simple demonstration here:
+
+```julia
+using DataInterpolations
+
+# Dependent variable
+u = [14.7, 11.51, 10.41, 14.95, 12.24, 11.22]
+
+# Independent variable
+t = [0.0, 62.25, 109.66, 162.66, 205.8, 252.3]
+
+A1 = CubicSpline(u, t)
+
+# For interpolation do, A(t)
+A1(100.0)
+
+# derivative
+## first order
+DataInterpolations.derivative(A1, 1.0, 1)
+
+## second order
+DataInterpolations.derivative(A1, 1.0, 2)
+
+# integral
+DataInterpolations.integral(A1, 1.0, 5.0)
+```