spelling corrections

murrayrm · murrayrm · commit 02f7a13a8450 · 2025-02-02T20:39:22.000-08:00
diff --git a/doc/intro.rst b/doc/intro.rst
@@ -49,7 +49,7 @@ To install using pip::
 
 .. note::
    If you install Slycot using pip you'll need a development
-   environment (e.g., Python development files, C, and Fortran compilers).
+   environment (e.g., Python development files, C, and FORTRAN compilers).
    Pip installation can be particularly complicated for Windows.
 
 Many parts of `python-control` will work without `slycot`, but some
@@ -81,7 +81,7 @@ control package::
       !pip install control
       import control as ct
 
-Note that Google colab does not currently support Slycot, so some
+Note that Google Colab does not currently support Slycot, so some
 functionality may not be available.
 
 
@@ -91,11 +91,11 @@ Package conventions
 The python-control package makes use of a few naming and calling conventions:
 
 * Function names are written in lower case with underscores between
-  words ('frequency_response').
+  words (`frequency_response`).
 
-* Class names use camel case ('StateSpace', 'ControlPlot', etc) and
-  instances of the class are created with "factory functions" ('ss')
-  or as the output of an operation ('bode_plot').
+* Class names use camel case (`StateSpace`, `ControlPlot`, etc) and
+  instances of the class are created with "factory functions" (`ss`)
+  or as the output of an operation (`bode_plot`).
 
 * Functions that return multiple values use either objects (with
   elements for each return value) or tuples.  For those functions that
@@ -105,10 +105,10 @@ The python-control package makes use of a few naming and calling conventions:
     K, _, _ = lqr(sys)
 
 * Python-control supports both single-input, single-output (SISO)
-  systems and mullti-input, multi-output (MIMO) systems, including
+  systems and multi-input, multi-output (MIMO) systems, including
   time and frequency responses.  By default, SISO systems will
   typically generate objects that have the input and output dimensions
-  supressed (using the NumPy :func:`~numpy.squeeze` function).  The
+  suppressed (using the NumPy :func:`~numpy.squeeze` function).  The
   `squeeze` keyword can be set to `False` to force functions to return
   objects that include the input and output dimensions.
 
@@ -136,7 +136,7 @@ some things to keep in mind:
 * Functions that in MATLAB would return variable numbers of values
   will have a parameter of the form `return_<val>` that is used to
   return additional data.  (These functions usually return an object of
-  a class that has attributpes that can be used to access the
+  a class that has attributes that can be used to access the
   information and this is the preferred usage pattern.)
 * You cannot use braces for collections; use tuples instead.
 * Time series data have time as the final index (see
diff --git a/doc/iosys.rst b/doc/iosys.rst
@@ -8,7 +8,7 @@ Interconnected I/O Systems
 
 Input/output systems can be interconnected in a variety of ways,
 including operator overloading, block diagram algebra functions, and
-using the :func:`interconnect` function to build a hiearchical system
+using the :func:`interconnect` function to build a hierarchical system
 description.  This chapter provides more detailed information on
 operator overloading and block diagram algebra, as well as a
 description of the :class:`InterconnectedSystem` class, which can be
@@ -23,7 +23,7 @@ The following operators are defined to operate between I/O systems:
    :header-rows: 1
 
    * - Operation
-     - Desription
+     - Description
      - Equivalent command
    * - `sys1 + sys2`
      - Add the outputs of two systems receiving the same input
@@ -104,7 +104,7 @@ signals to be specified using the usual `name`, `inputs`, and
 `outputs` keywords, as described in the :class:`InputOutputSystem`
 class.  For state space systems, the names of the states can also be
 given, but caution should be used since the order of states in the
-combined system is not gauranteed.
+combined system is not guaranteed.
 
 
 Signal-based interconnection
@@ -444,9 +444,9 @@ is not specified, then it defaults to the minimum or maximum value of
 the signal range.  Note that despite the similarity to slice notation,
 negative indices and step specifications are not supported.
 
-Using   these  various   forms  can   simplfy  the   specification  of
+Using these various forms can simplify the specification of
 interconnections.  For example, consider a process with inputs 'u' and
-'v',  each of  dimension  2, and  two  outputs 'w'  and  'y', each  of
+'v', each of dimension 2, and two outputs 'w' and 'y', each of
 dimension 2::
 
   P = ct.rss(
@@ -472,7 +472,7 @@ the closed loop system to consist of all system outputs `y` and `z`,
 as well as the controller input `u`.
 
 This collection of systems can be combined in a variety of ways.  The
-most explict would specify every signal::
+most explicit would specify every signal::
 
   clsys1 = ct.interconnect(
     [C, P, sumblk],
@@ -569,7 +569,8 @@ feedforward gain (normally chosen so that the steady state output
 
 A reference gain controller can be created with the command::
 
-  ctrl, clsys = ct.create_statefbk_iosystem(sys, K, kf, feedfwd_pattern='refgain')
+  ctrl, clsys = ct.create_statefbk_iosystem(
+      sys, K, kf, feedfwd_pattern='refgain')
 
 This reference gain design pattern is described in more detail in
 Section 7.2 of `Feedback Systems <http://fbsbook.org>`_ (Stabilization
diff --git a/doc/linear.rst b/doc/linear.rst
@@ -64,7 +64,7 @@ operations as well as the :func:`feedback`, :func:`parallel`, and
 :ref:`function-ref`.
 
 The :func:`rss` function can be used to create a random state space
-system with a desired numbef or inputs, outputs, and states::
+system with a desired number or inputs, outputs, and states::
 
   sys = ct.rss(states=4, outputs=1, inputs=1], strictly_proper=True)
 
@@ -160,15 +160,15 @@ and `response.response` (for the complex response).
 Multi-input, multi-output (MIMO) systems
 ----------------------------------------
 
-Multi-input, multi-output (MIMO) sytems are created by providing
+Multi-input, multi-output (MIMO) systems are created by providing
 parameters of the appropriate dimensions to the relevant factory
 function.  For transfer functions, this is done by providing a 2D list
 of numerator and denominator polynomials to the :func:`tf` function,
 e.g.::
 
   sys = ct.tf(
       [[num11, num12], [num21, num22]],
-      [[den11, den12], [den21, denm22]])
+      [[den11, den12], [den21, den22]])
 
 Similarly, MIMO frequency response data (FRD) systems are created by
 providing the :func:`frd` function with a 3D array of response
@@ -252,7 +252,7 @@ time system from a continuous time system.  See
 changing the value of `config.defaults['control.default_dt']`.
 
 Functions operating on LTI systems will take into account whether a
-system is continous time or discrete time when carrying out operations
+system is continuous time or discrete time when carrying out operations
 that depend on this difference.  For example, the :func:`rss` function
 will place all system eigenvalues within the unit circle when called
 using `dt` corresponding to a discrete time system::
@@ -271,7 +271,7 @@ Model conversion and reduction
 ==============================
 
 A variety of functions are available to manipulate LTI systems,
-including functions for convering between state space and frequency
+including functions for converting between state space and frequency
 domain, sampling systems in time and frequency domain, and creating
 reduced order models.
 
@@ -286,7 +286,7 @@ explicit conversions are not necessary, since functions designed to
 operate on LTI systems will work on any subclass.
 
 To explicitly convert a state space system into a transfer function
-represetation, the state space system can be passed as an argument to
+representation, the state space system can be passed as an argument to
 the :func:`tf` factory functions::
 
   sys_ss = ct.rss(4, 2, 2, name='sys_ss')
@@ -315,7 +315,7 @@ Conversion of transfer functions to state space form is also possible::
 Time sampling
 -------------
 
-Continous time systems can be converted to discrete time systems using
+Continuous time systems can be converted to discrete time systems using
 the :func:`sample_system` function and specifying a sampling time::
 
   >> csys = ct.rss(4, 2, 2, name='csys')
@@ -345,7 +345,7 @@ the :func:`sample_system` function and specifying a sampling time::
   dt = 0.1
 
 Note that the system name for the discrete time system is the name of
-the origal system with the string '$sampled' appended.
+the original system with the string '$sampled' appended.
 
 Discrete time systems can also be created using the
 :func:`StateSpace.sample` or :func:`TransferFunction.sample` methods
@@ -410,7 +410,7 @@ realization on the stable part, then reinserts the unstable modes.
 
 The :func:`minimal_realization` function eliminates uncontrollable or
 unobservable states in state space models or cancels pole-zero pairs
-in transfer functions. The resuling output system has minimal order
+in transfer functions. The resulting output system has minimal order
 and the same input/output response characteristics as the original
 model system.  Unlike the :func:`balanced_reduction` function, the
 :func:`minimal_realization` eliminates all uncontrollable and/or
@@ -457,7 +457,7 @@ Information about an LTI system can be obtained using the Python
   D = [[-0.  0.]
        [ 0.  0.]]
 
-For a more compact represention, LTI objects can be evaluated directly
+For a more compact representation, LTI objects can be evaluated directly
 to return a summary of the system input/output properties::
 
   >>> sys = ct.rss(4, 2, 2, name='sys_2x2')
diff --git a/doc/nlsys.rst b/doc/nlsys.rst
@@ -30,10 +30,10 @@ The `updfcn` argument is a function returning the state update function::
   updfcn(t, x, u, params) -> array
 
 where `x` is a 1-D array with shape (n,), `u` is a 1-D array
-with shape (m,), `t` is a float representing the currrent time,
+with shape (m,), `t` is a float representing the current time,
 and `params` is a dict containing the values of parameters used by the
 function.  The dynamics of the system can be in continuous or discrete
-time (use the `dt` keyword to create a discrte time system).
+time (use the `dt` keyword to create a discrete time system).
 
 The output function `outfcn` is used to specify the outputs of the
 system and has the same calling signature as `updfcn`.  If it is not
@@ -135,7 +135,8 @@ time systems).
 More complex operating points can be found by specifying which states,
 inputs, or outputs should be used in computing the operating point, as
 well as desired values of the states, inputs, outputs, or state
-updates.  See the :func:`find_operating_point` documentation for more deatils.
+updates.  See the :func:`find_operating_point` documentation for more
+details.
 
 
 Simulations and plotting
diff --git a/doc/optimal.rst b/doc/optimal.rst
@@ -279,7 +279,7 @@ Plotting the results::
   plt.xlabel("t [sec]")
   plt.ylabel("u2 [rad/s]")
 
-  plt.suptitle("Lane change manuever")
+  plt.suptitle("Lane change maneuver")
   plt.tight_layout()
   plt.show()
 
diff --git a/doc/stochastic.rst b/doc/stochastic.rst
@@ -15,16 +15,15 @@ Stochastic signals
 ==================
 
 A stochastic signal is a representation of the output of a random
-process.  NumPy and SciPy have a number of functions to calculate the
-covariance and correlation of random signals:
-
-  * :func:`numpy.cov` - returns the sample variance of vector random
-    variable :math:`X \in \mathbb{R}^n` where the input argument
-    represents samples of :math:`X`.
-
-  * :func:`numpy.cov` - returns the (cross-)covariance of the
-    variables :math:`X` and :math:`Y` where the input arguments
-    represent samples of the given random variables.
+process.  NumPy and SciPy have a functions to calculate the covariance
+and correlation of random signals:
+
+  * :func:`numpy.cov` - with a single argument, returns the sample
+    variance of a vector random variable :math:`X \in \mathbb{R}^n`
+    where the input argument represents samples of :math:`X`.  With
+    two arguments, returns the (cross-)covariance of random variables
+    :math:`X` and :math:`Y` where the input arguments represent
+    samples of the given random variables.
 
   * :func:`scipy.signal.correlate` - the "cross-correlation" between two
     random (1D) sequences.  If these sequences came from a random
