code: public synchronized void processSpace(Transform transform) {
          if (transform == null) 
              throw new NullPointerException("transform cannot be null");
  
          // Figure out whether we're using the original integer-valued count
          // vectors or this instance has been transformed, in which case we
          // support sequential transformations.
          Map<String,? extends Vector> wordToVector =
              (wordToTransformedVector != null)
              ? wordToTransformedVector
              : wordToSemantics;
  
          // Create a Matrix instance from the current word vectors, keeping track
          // of which word corresponds to which vector
          List<String> wordsInOrder = new ArrayList<String>(wordToVector.size());
          List<DoubleVector> vectorsInOrder =
              new ArrayList<DoubleVector>(wordToVector.size());
          for (Map.Entry<String,? extends Vector> e
                   : wordToVector.entrySet()) {
              wordsInOrder.add(e.getKey());
              // The subview is necessary to control for the length of the
              // vectors, which are potentially unbounded.
              vectorsInOrder.add(Vectors.asDouble(
                  Vectors.subview(e.getValue(), 0, getVectorLength())));
          }
          Matrix m = Matrices.asMatrix(vectorsInOrder);
          
          // Transform the original vectors according to the user's specification
          Matrix transformed = transform.transform(m);
  
          // Replace the state of this SemanticSpace with the transformed vectors
          wordToSemantics.clear();
          int n = wordsInOrder.size();
          wordToTransformedVector = new HashMap<String,DoubleVector>(n);
          for (int i = 0; i < n; ++i) {
              wordToTransformedVector.put(
                  wordsInOrder.get(i), transformed.getRowVector(i));
          }
      }
docs: Transforms the vectors in this instance according to the logic specified
  in the {@code transform} instance.  Note that this method supports being
  called multiple times, enabling sequentially transforming the values
  using a series of {@link Transform} instances.
  
  @param transform the way in which this instance's word vectors should be
  transformmed.