How to use

ParseTokenScalarFunction

in

cc.redberry.core.parser

return new ParseTokenScalarFunction(temp, new ParseToken[]{parser.parse(argument)});

public static ParseToken tensor2AST(Tensor tensor) {
  if (tensor instanceof TensorField) {
    TensorField tf = (TensorField) tensor;
    ParseToken[] content = new ParseToken[tf.size()];
    int i = 0;
    for (Tensor t : tf)
      content[i++] = tensor2AST(t);
    return new ParseTokenTensorField(tf.getIndices(), tf.getStringName(), content, tf.getArgIndices());
  }
  if (tensor instanceof SimpleTensor) {
    SimpleTensor st = (SimpleTensor) tensor;
    return new ParseTokenSimpleTensor(st.getIndices(), st.getStringName());
  }
  if (tensor instanceof Complex)
    return new ParseTokenNumber((Complex) tensor);
  if (tensor instanceof Expression)
    return new ParseTokenExpression(false, tensor2AST(tensor.get(0)), tensor2AST(tensor.get(1)));
  ParseToken[] content = new ParseToken[tensor.size()];
  int i = 0;
  for (Tensor t : tensor)
    content[i++] = tensor2AST(t);
  if (tensor instanceof ScalarFunction)
    return new ParseTokenScalarFunction(tensor.getClass().getSimpleName(), content);
  return new ParseToken(TokenType.valueOf(tensor.getClass().getSimpleName()), content);
}

@Override
public ParseToken transform(ParseToken node) {
  TokenType type = node.tokenType;
  switch (type) {
    case SimpleTensor:
      ParseTokenSimpleTensor st = (ParseTokenSimpleTensor) node;
      NameAndStructureOfIndices ds = st.getIndicesTypeStructureAndName();
      return new ParseTokenSimpleTensor(transformIndices(st.getIndices(), ds),
          transformer.newName(ds.getName(), ds));
    case TensorField:
      ParseTokenTensorField tf = (ParseTokenTensorField) node;
      ParseToken[] newContent = transformContent(tf.content);
      SimpleIndices[] newArgsIndices = new SimpleIndices[tf.argumentsIndices.length];
      for (int i = newArgsIndices.length - 1; i >= 0; --i)
        newArgsIndices[i] = IndicesFactory.createSimple(null, newContent[i].getIndices());
      NameAndStructureOfIndices dsf = tf.getIndicesTypeStructureAndName();
      return new ParseTokenTensorField(transformIndices(tf.getIndices(), dsf),
          transformer.newName(dsf.getName(), dsf), newContent, newArgsIndices);
    case Number:
      return node;
    case ScalarFunction:
      return new ParseTokenScalarFunction(((ParseTokenScalarFunction) node).function, transformContent(node.content));
    case Expression:
      ParseToken[] nContent = transformContent(node.content);
      return new ParseTokenExpression(((ParseTokenExpression) node).preprocess, nContent[0], nContent[1]);
    default:
      return new ParseToken(node.tokenType, transformContent(node.content));
  }
}