code: def test_multiple_functions(self):
      a = T.scalar()  # the a is for 'anonymous' (un-named).
      x, s = T.scalars("xs")
      v = T.vector("v")
  
      # put in some inputs
      list_of_things = [s, x, v]
  
      # some derived thing, whose inputs aren't all in the list
      list_of_things.append(a * x + s)
  
      f1 = function(
          [
              x,
              In(a, value=1.0, name="a"),
              In(s, value=0.0, update=s + a * x, mutable=True),
          ],
          s + a * x,
      )
      list_of_things.append(f1)
  
      # now put in a function sharing container with the previous one
      f2 = function(
          [
              x,
              In(a, value=1.0, name="a"),
              In(
                  s,
                  value=f1.container[s],
                  update=s + a * x,
                  mutable=True,
              ),
          ],
          s + a * x,
      )
      list_of_things.append(f2)
  
      assert isinstance(f2.container[s].storage, list)
      assert f2.container[s].storage is f1.container[s].storage
  
      # now put in a function with non-scalar
      v_value = np.asarray([2, 3, 4.0], dtype=config.floatX)
      f3 = function([x, In(v, value=v_value)], x + v)
      list_of_things.append(f3)
  
      # try to pickle the entire things
      try:
          saved_format = pickle.dumps(list_of_things, protocol=-1)
          new_list_of_things = pickle.loads(saved_format)
      except NotImplementedError as e:
          if e[0].startswith("DebugMode is not picklable"):
              return
          else:
              raise
  
      # now test our recovered new_list_of_things
      # it should be totally unrelated to the original
      # it should be interdependent in the same way as the original
  
      ol = list_of_things
      nl = new_list_of_things
  
      for i in range(4):
          assert nl[i] != ol[i]
          assert nl[i].type == ol[i].type
          assert nl[i].type is not ol[i].type
  
      # see if the implicit input got stored
      assert ol[3].owner.inputs[1] is s
      assert nl[3].owner.inputs[1] is not s
      assert nl[3].owner.inputs[1].type == s.type
  
      # moving on to the functions...
      for i in range(4, 7):
          assert nl[i] != ol[i]
  
      # looking at function number 1, input 's'
      assert nl[4][nl[0]] is not ol[4][ol[0]]
      assert nl[4][nl[0]] == ol[4][ol[0]]
      assert nl[4](3) == ol[4](3)
  
      # looking at function number 2, input 's'
      # make sure it's shared with the first function
      assert (
          ol[4].container[ol[0]].storage
          is ol[5].container[ol[0]].storage
      )
      assert (
          nl[4].container[nl[0]].storage
          is nl[5].container[nl[0]].storage
      )
      assert nl[5](3) == ol[5](3)
      assert nl[4].value[nl[0]] == 6
  
      assert np.all(nl[6][nl[2]] == np.asarray([2, 3.0, 4]))
  
imports: from __future__ import absolute_import, print_function, division
  import copy
  import six.moves.cPickle
  import numpy
  import unittest
  import time
  from theano import config, gof
  from six import iteritems
  from theano.compile.io import In, Out
  from theano.compile import function
  from theano.compile import UnusedInputError
  from theano.gof import MissingInputError
  from theano.compat import exc_message
  from theano.tests.unittest_tools import SkipTest
  from theano import tensor
  from theano import tensor
  import theano
label_desc: Use image node_id 7 for calling the T_picklefunction obj's underlying member method code with example usage: obj.test_multiple_functions() without return types