Make all apostrophe and quote characters in texts plain ASCII

Author: jougs

ACKNOWLEDGMENTS.md

@@ -1,10 +1,10 @@
 **Acknowledgments**
 
-NEST development has been supported by many organisations, programs, and 
-individuals since 1993. The following list of support received is therefore 
+NEST development has been supported by many organisations, programs, and
+individuals since 1993. The following list of support received is therefore
 necessarily incomplete.
 
-This project has received funding from the European Union’s Horizon 2020 
+This project has received funding from the European Union's Horizon 2020
 Framework Programme for Research and Innovation under Specific Grant Agreement:
 
 - No. 945539 (Human Brain Project SGA3),
@@ -13,7 +13,7 @@ Framework Programme for Research and Innovation under Specific Grant Agreement:
 - No. 754304 (DEEP-EST), and
 - No. 800858 (ICEI).
 
-The NEST developers gratefully acknowledge the support and funding received 
+The NEST developers gratefully acknowledge the support and funding received
 from:
 
 - Jülich Aachen Research Alliance (JARA),

doc/htmldoc/developer_space/guidelines/code_review_guidelines.rst

@@ -19,7 +19,7 @@ can be discussed on the :ref:`NEST mailing lists <contact_us>`.
   does the right thing and is architecturally sound) and the content
   side (i.e., if the code is scientifically correct and fixes an
   actual issue).
-* For changes labeled “not code” or “minor” (e.g., changes in
+* For changes labeled "not code" or "minor" (e.g., changes in
   documentation, fixes for typos, etc.), the need for a second code
   review can be waived, and a single review plus the OK from the CI
   system is sufficient to merge the request.

doc/htmldoc/developer_space/sli_docs/first-steps.rst

@@ -166,5 +166,5 @@ on the stack. ``patsck`` Display the stack in syntax form. ``stack``
 Display the stack. ``pop``, ``;`` Pop object from stack. ``npop`` Pop
 ``n`` objects from stack. ``dup`` Duplicate top object of stack.
 ``copy`` Copy the first n objects of the stack. ``index`` Copy the
-``n``\ ’th object of the stack. ``roll`` Roll a portion of ``n`` stack
+``n``\ 'th object of the stack. ``roll`` Roll a portion of ``n`` stack
 levels ``k`` times. ``exec`` Execute the top element on the stack.

doc/htmldoc/developer_space/sli_docs/neural-simulations.rst

@@ -9,7 +9,7 @@ Overview
 --------
 
 A simulation of a network is like an experiment with the difference that
-it takes place inside the computer’s memory rather than in the physical
+it takes place inside the computer's memory rather than in the physical
 world.
 
 Like in a real experiment, you need a system which you want to
@@ -232,7 +232,7 @@ In the fist line, we create one integrate and fire neuron from the model
 The return value of ``Create`` is an integer that identifies the last
 node that was created in the network (note that this can be different
 from 1 if you have not called ``ResetKernel before)``. This integer is
-called the node’s *node ID* (the network as a whole owns the node ID
+called the node's *node ID* (the network as a whole owns the node ID
 ``0``, therefore the ids of user-created nodes start with ``1``). Often,
 it is neccessary to have a large number of nodes of the same type. The
 command Create can also be used for this purpose. The following line of
@@ -295,7 +295,7 @@ the threshold value ``V_th`` to -60 mV:
    -60
 
 Please note, that ``SetStatus`` checks if a property really exists in a
-node and will issue an error if it doesn’t. This behavior can be changed
+node and will issue an error if it doesn't. This behavior can be changed
 by the following command:
 
 ::
@@ -318,7 +318,7 @@ expected type:
        Provided datatype: stringtype
 
 In order to find out, which properties of a given model can be changed
-an which not, you have to refer to the model’s documentation.
+an which not, you have to refer to the model's documentation.
 
 Connections
 -----------
@@ -416,7 +416,7 @@ By definition, a device is active in the interval \\((t_1,t_2)\) if we
 can observe events \\(E\) with time stamps \\(t_E\) which obey \\(t_1 <=
 t_E < t_2\) for all \\(E\) . In other words, the interval during which
 the device is active corresponds to the range of time-stamps of the
-device’s events.
+device's events.
 
 Note that it is not possible to generate/observe an event with time
 stamp 0.

doc/htmldoc/developer_space/sli_docs/objects-and-data-types.rst

@@ -116,7 +116,7 @@ Strings
 
 Strings are sequences of characters, delimited by parenthesis. In SLI,
 characters are represented by interger numbers, e.g. 97 represents the
-letter ‘a’, while 32 represents the *space* character.
+letter "a", while 32 represents the *space* character.
 
 The elements of a string are indexed, starting with zero (0) as the
 first index.

doc/htmldoc/developer_space/sli_docs/programming-in-sli.rst

@@ -30,12 +30,12 @@ A program is a sequence of SLI objects and procedures which are defined
 in a file. Program files are ordinary ASCII text files, which can be
 created and modified with an editor of your choice (e.g. GNU Emacs).
 
-SLI programs usually have the file ending “sli”, for example
+SLI programs usually have the file ending "sli", for example
 ``hello_world.sli``.
 
 The ``run`` command is used to execute a program file.
 
-Example: “Hello World!”
+Example: "Hello World!"
 ~~~~~~~~~~~~~~~~~~~~~~~
 
 Write the program ``hello_world.sli`` according to the example, given
@@ -236,7 +236,7 @@ The simplest loop is performed by the command ``loop``:
       :
 
 ``loop`` performs the procedure repeatedly and thus in the example, an
-infinite succession of the words “Hello World” is printed. The only way
+infinite succession of the words "Hello World" is printed. The only way
 to leave a ``loop``-structure is to call the command ``exit`` somewhere
 inside the loop:
 
@@ -246,7 +246,7 @@ inside the loop:
    SLI [1] { 1 add dup  (Hello World) = 10 eq {exit} if }
    SLI [2] loop
 
-it prints ten times ‘Hello World’. First the initial value 0 is pushed
+it prints ten times "Hello World". First the initial value 0 is pushed
 on the operand stack. The procedure adds 1 in each cycle and takes care
 that one copy of the counter stays on the stack to serve as the initial
 value for the next cycle. After the message has been printed, the stop
@@ -263,7 +263,7 @@ Finite loops
 The last example can be implemented much easier, using a ``repeat``
 loop. ``repeat`` takes two arguments: An integer, and a procedure
 object. The integer determines how often the procedure is executed.
-Thus, in order to print ten times “Hello World” we write:
+Thus, in order to print ten times "Hello World" we write:
 
 ::
 

doc/htmldoc/developer_space/sli_docs/using-files-and-keyboard-input.rst

@@ -8,7 +8,7 @@ Using files and keyboard input
 Overview
 --------
 
-SLI’s input/output fascilities differ from those of PostScript and are
+SLI's input/output fascilities differ from those of PostScript and are
 close to the stream concept of C++. However, for compatibility some
 PostScript output commands are implemented.
 
@@ -29,7 +29,7 @@ Print *Hello World* to the standard output.
    SLI ]
 
 ``cout`` is the standard output of SLI. The command ``<-`` takes the
-role of C++’s ``<<`` output operator and prints the ASCII representation
+role of C++'s ``<<`` output operator and prints the ASCII representation
 of the object at stack level 0 to the stream at level 1. After this, the
 object is removed and the stream remains at level 0.
 
@@ -111,7 +111,7 @@ to right of the field. ``ostream internal`` Sign left and number right.
 ``stream uppercase`` ``ostream nouppercase`` ``ostream oct`` Switch to
 octal notation. ``ostream dec`` Switch to decimal notation.
 ``ostream hex`` Switch to hexadecimal notation. ``ostream showbase``
-Show base according to use of oct/dec/hex. ``ostream noshowbase`` Don’t
+Show base according to use of oct/dec/hex. ``ostream noshowbase`` Don't
 show base according to use of oct/dec/hex. ``ostream showpoint`` Decimal
 point is always printed. ``ostream noshowpoint`` Decimal point is never
 printed. ``ostream n setprecision`` Set number of decimal places to

doc/htmldoc/developer_space/workflows/development_workflow.rst

@@ -29,7 +29,7 @@ Setting up your GitHub account
 ##############################
 
 The NEST source code is hosted in a public repository on
-`GitHub <https://github.com/nest/nest-simulator>`_. If you don’t have a GitHub
+`GitHub <https://github.com/nest/nest-simulator>`_. If you don't have a GitHub
 account already, please create one.
 
 You then need to configure your account to allow write access - please see the
@@ -80,7 +80,7 @@ Commands explained
 
 This downloads your fork to your local system.  Investigate. Change directory
 to your new repository: ``cd nest-simulator``.
-Then ``git branch -a`` to show you all branches. You’ll get something like:
+Then ``git branch -a`` to show you all branches. You'll get something like:
 
 .. code::
 
@@ -109,7 +109,7 @@ the main source code repository is usually called ``upstream``.
 
 .. note::
 
-   We’ve used ``git://`` in the web address instead of ``git@``.
+   We've used ``git://`` in the web address instead of ``git@``.
    The ``git://`` web address is read only and ensures that you don't make any
    accidental changes to the ``upstream`` repository (if you have permissions to
    write to it, of course).

doc/htmldoc/faqs/qa-precise-spike-times.rst

@@ -16,8 +16,8 @@ different spike sequences after a short time.
     expression or an iterative procedure like Newton-Raphson lead to
     machine independent spike sequences?**
 
-A: No. For example, if machine A uses “double” for the representation of
-floating point numbers and machine B uses “quad” precision, the spike
+A: No. For example, if machine A uses "double" for the representation of
+floating point numbers and machine B uses "quad" precision, the spike
 sequences of the two simulations deviate after a short time. Even with
 the same representation of floating point values, results rapidly
 diverge if some library function like exp() is implemented in a slightly
@@ -89,7 +89,7 @@ A: No, for many scientific problems a limited precision is good enough.
 The fastest method delivering at least the required precision is the one
 of choice. In the case of chaotic dynamics there is generally no good
 reason to consider results produced by a neuron model implementation
-with high precision as being ‘more correct’ than those produced by a
+with high precision as being 'more correct' than those produced by a
 faster implementation with lower precision, as long as mesoscopic
 measures of interest remain unchanged. With a more accurate method at
 hand, the researcher can always carry out control simulations at higher

doc/htmldoc/nest_behavior/random_numbers.rst

@@ -380,7 +380,7 @@ estimate the number of random numbers required per stream as follows:
 Collision risk of parallel random number streams
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-`L’Ecuyer et al (2017) <https://dx.doi.org/10.1016/j.matcom.2016.05.005>`__ provide a
+`L'Ecuyer et al (2017) <https://dx.doi.org/10.1016/j.matcom.2016.05.005>`__ provide a
 recent account of random number generation in highly parallel settings.
 The main approach to providing independent random number streams in
 parallel simulations is to use a high-quality random number generator
@@ -414,10 +414,10 @@ while for a period of :math:`r = 2^{256}` we obtain
 The probability of stream collisions is thus negligibly small, provided
 we use random number generators with a period of at least :math:`2^{128}`.
 
-`L’Ecuyer (2012, Ch 3.6) <https://doi.org/10.1007/978-3-642-21551-3_3>`__ points out
+`L'Ecuyer (2012, Ch 3.6) <https://doi.org/10.1007/978-3-642-21551-3_3>`__ points out
 that certain random number generator classes will show too much
 regularity in their output if more than :math:`r^{1/3}` numbers are used (this
-relation is based on exercises in Knuth, TAOCP vol 2, see `L’Ecuyer and
+relation is based on exercises in Knuth, TAOCP vol 2, see `L'Ecuyer and
 Simard (2001) <https://doi.org/10.1016/S0378-4754(00)00253-6>`__). While
 it is not certain that that analysis also applies to (short)
 subsequences of the period of an RNG, one might still re-consider the