Stochastic equations can be falsely identified as multiplicative
The following code will not run, because Brian considers the noise to be multiplicative:
```Python
ta = TimedArray([0, 1], dt=defaultclock.dt*10)
group = NeuronGroup(1, 'dv/dt = ta(t)*xi*(5*ms)**-0.5 :1', method='euler')
```
For the `exact` state updater, we already deal with this situation by checking whether `ta` is constant over a time step, we should do the same for stochastic equations.

The workaround is straight-forward, you can select a state updater that supports multiplicative noise (e.g. `heun`)

First reported by Martin Bertele [on the mailing list](https://groups.google.com/d/topic/briansupport/2haOThEAeF4/discussion).
diff --git a/brian2/equations/equations.py b/brian2/equations/equations.py
index a2954190..cf2958d6 100644
--- a/brian2/equations/equations.py
+++ b/brian2/equations/equations.py
@@ -797,9 +797,7 @@ def _get_stochastic_type(self):
             time), ``'multiplicative'`` (at least one of the noise factors
             depends on other state variables and/or time).
         '''
-        
-        # TODO: Add debug output
-        
+
         if not self.is_stochastic:
             return None
         
diff --git a/brian2/stateupdaters/explicit.py b/brian2/stateupdaters/explicit.py
index 92687c90..18d2f721 100644
--- a/brian2/stateupdaters/explicit.py
+++ b/brian2/stateupdaters/explicit.py
@@ -13,7 +13,7 @@
 from past.builtins import basestring
 
 from brian2.parsing.sympytools import str_to_sympy, sympy_to_str
-
+from brian2.equations.codestrings import is_constant_over_dt
 from .base import (StateUpdateMethod, UnsupportedEquationsException,
                    extract_method_options)
 
@@ -581,18 +581,10 @@ def __call__(self, eqs, variables=None, method_options=None):
         method_options = extract_method_options(method_options, {})
         # Non-stochastic numerical integrators should work for all equations,
         # except for stochastic equations
-        if eqs.is_stochastic:
-            if self.stochastic is None:
-                raise UnsupportedEquationsException('Cannot integrate '
-                                                    'stochastic equations with '
-                                                    'this state updater.')
-            if (self.stochastic != 'multiplicative' and
-                        eqs.stochastic_type == 'multiplicative'):
-                raise UnsupportedEquationsException('Cannot integrate '
-                                                    'equations with '
-                                                    'multiplicative noise with '
-                                                    'this state updater.')
-
+        if eqs.is_stochastic and self.stochastic is None:
+            raise UnsupportedEquationsException('Cannot integrate '
+                                                'stochastic equations with '
+                                                'this state updater.')
         if self.custom_check:
             self.custom_check(eqs, variables)
         # The final list of statements
@@ -638,7 +630,34 @@ def __call__(self, eqs, variables=None, method_options=None):
                 
         # Process the "return" line of the stateupdater description
         non_stochastic_expr, stochastic_expr = split_expression(self.output)
-        
+
+        if eqs.is_stochastic and (self.stochastic != 'multiplicative' and
+                                  eqs.stochastic_type == 'multiplicative'):
+            # The equations are marked as having multiplicative noise and the
+            # current state updater does not support such equations. However,
+            # it is possible that the equations do not use multiplicative noise
+            # at all. They could depend on time via a function that is constant
+            # over a single time step (most likely, a TimedArray). In that case
+            # we can integrate the equations
+            dt_value = variables['dt'].get_value()[0] if 'dt' in variables else None
+            for _, expr in substituted_expressions:
+                _, stoch = expr.split_stochastic()
+                if stoch is None:
+                    continue
+                # There could be more than one stochastic variable (e.g. xi_1, xi_2)
+                for _, stoch_expr in stoch.items():
+                    sympy_expr = str_to_sympy(stoch_expr.code)
+                    # The equation really has multiplicative noise, if it depends
+                    # on time (and not only via a function that is constant
+                    # over dt), or if it depends on another variable defined
+                    # via differential equations.
+                    if (not is_constant_over_dt(sympy_expr, variables, dt_value)
+                            or len(stoch_expr.identifiers & eqs.diff_eq_names)):
+                        raise UnsupportedEquationsException('Cannot integrate '
+                                                            'equations with '
+                                                            'multiplicative noise with '
+                                                            'this state updater.')
+
         # Assign a value to all the model variables described by differential
         # equations
         for var, expr in substituted_expressions:
diff --git a/brian2/tests/test_stateupdaters.py b/brian2/tests/test_stateupdaters.py
index 5f630b8c..7effab95 100644
--- a/brian2/tests/test_stateupdaters.py
+++ b/brian2/tests/test_stateupdaters.py
@@ -184,6 +184,49 @@ def test_multiple_noise_variables_deterministic_noise():
                             err_msg='Method %s gave incorrect results' % method_name)
 
 
+@attr('codegen-independent')
+def test_multiplicative_noise():
+    # Noise is not multiplicative (constant over time step)
+    ta = TimedArray([0, 1], dt=defaultclock.dt*10)
+    Eq = Equations('dv/dt = ta(t)*xi*(5*ms)**-0.5 :1')
+    group = NeuronGroup(1, Eq, method='euler')
+    net = Network(group)
+    net.run(0*ms)  # no error
+    
+    # Noise is multiplicative (multiplied with time-varying variable)
+    Eq1 = Equations('dv/dt = v*xi*(5*ms)**-0.5 :1')
+    group1 = NeuronGroup(1, Eq1, method='euler')
+    net1 = Network(group1)
+    assert_raises(UnsupportedEquationsException, net1.run, 0*ms)
+
+    # Noise is multiplicative (multiplied with time)
+    Eq2 = Equations('dv/dt = (t/ms)*xi*(5*ms)**-0.5 :1')
+    group2 = NeuronGroup(1, Eq2, method='euler')
+    net2 = Network(group2)
+    assert_raises(UnsupportedEquationsException, net2.run, 0*ms)
+
+    # Noise is multiplicative (multiplied with time-varying variable)
+    Eq3 = Equations('''dv/dt = w*xi*(5*ms)**-0.5 :1
+                       dw/dt = -w/(10*ms) : 1''')
+    group3 = NeuronGroup(1, Eq3, method='euler')
+    net3 = Network(group3)
+    assert_raises(UnsupportedEquationsException, net3.run, 0*ms)
+
+    # One of the equations has multiplicative noise
+    Eq4 = Equations('''dv/dt = xi_1*(5*ms)**-0.5 : 1
+                       dw/dt = (t/ms)*xi_2*(5*ms)**-0.5 :1''')
+    group4 = NeuronGroup(1, Eq4, method='euler')
+    net4 = Network(group4)
+    assert_raises(UnsupportedEquationsException, net4.run, 0*ms)
+
+    # One of the equations has multiplicative noise
+    Eq5 = Equations('''dv/dt = xi_1*(5*ms)**-0.5 : 1
+                       dw/dt = v*xi_2*(5*ms)**-0.5 :1''')
+    group5 = NeuronGroup(1, Eq5, method='euler')
+    net5 = Network(group4)
+    assert_raises(UnsupportedEquationsException, net5.run, 0*ms)
+
+
 @with_setup(setup=store_randn, teardown=restore_randn)
 def test_pure_noise_deterministic():
     DEFAULT_FUNCTIONS['randn'] = fake_randn
@@ -749,6 +792,7 @@ def test_check_for_invalid_values_linear_integrator():
     test_explicit_stateupdater_parsing()
     test_non_autonomous_equations()
     test_str_repr()
+    test_multiplicative_noise()
     test_multiple_noise_variables_basic()
     test_multiple_noise_variables_extended()
     store_randn()
diff --git a/docs_sphinx/introduction/release_notes.rst b/docs_sphinx/introduction/release_notes.rst
index 9b4f7561..269be5c3 100644
--- a/docs_sphinx/introduction/release_notes.rst
+++ b/docs_sphinx/introduction/release_notes.rst
@@ -10,6 +10,8 @@ Selected improvements and bug fixes
 * `~brian2.groups.group.Group.run_regularly` operations are now included in the network, even if they are
   created after the parent object was added to the network (:issue:`1009`).
   Contributed by `Vigneswaran Chandrasekaran <https://github.com/Vigneswaran-Chandrasekaran>`_.
+* No longer incorrectly classify some equations as having "multiplicative noise" (:issue:`968`).
+  Contributed by `Vigneswaran Chandrasekaran <https://github.com/Vigneswaran-Chandrasekaran>`_.
 
 Backward-incompatible changes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
['brian2/stateupdaters/explicit.py', 'brian2/tests/test_stateupdaters.py', 'docs_sphinx/introduction/release_notes.rst', 'brian2/equations/equations.py']