yijunyu/c-to-rust huggingface dataset:
// Original:
public GreekStemFilterFactory(Map<String,String> args) {super(args);if (!args.isEmpty()) {throw new IllegalArgumentException("Unknown parameters: " + args);}}

// Translation:
public GreekStemFilterFactory(IDictionary<string, string> args): base(args){if (args.Count > 0){throw new System.ArgumentException("Unknown parameters: " + args);}}
// Original:
public RegisterTypeResult registerType(RegisterTypeRequest request) {request = beforeClientExecution(request);return executeRegisterType(request);}

// Translation:
public virtual RegisterTypeResponse RegisterType(RegisterTypeRequest request){var options = new InvokeOptions();options.RequestMarshaller = RegisterTypeRequestMarshaller.Instance;options.ResponseUnmarshaller = RegisterTypeResponseUnmarshaller.Instance;return Invoke<RegisterTypeResponse>(request, options);}
// Original:
public GetAccessControlEffectResult getAccessControlEffect(GetAccessControlEffectRequest request) {request = beforeClientExecution(request);return executeGetAccessControlEffect(request);}

// Translation:
public virtual GetAccessControlEffectResponse GetAccessControlEffect(GetAccessControlEffectRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetAccessControlEffectRequestMarshaller.Instance;options.ResponseUnmarshaller = GetAccessControlEffectResponseUnmarshaller.Instance;return Invoke<GetAccessControlEffectResponse>(request, options);}
// Original:
public HSSFShapeGroup createGroup(HSSFChildAnchor anchor) {HSSFShapeGroup group = new HSSFShapeGroup(this, anchor);group.setParent(this);group.setAnchor(anchor);shapes.add(group);onCreate(group);return group;}

// Translation:
public HSSFShapeGroup CreateGroup(HSSFChildAnchor anchor){HSSFShapeGroup group = new HSSFShapeGroup(this, anchor);group.Parent = this;group.Anchor = anchor;shapes.Add(group);OnCreate(group);return group;}
// Original:
public String toExternalString() {final StringBuilder r = new StringBuilder();appendSanitized(r, getName());r.append(" <"); appendSanitized(r, getEmailAddress());r.append("> "); r.append(when / 1000);r.append(' ');appendTimezone(r, tzOffset);return r.toString();}

// Translation:
public virtual string ToExternalString(){StringBuilder r = new StringBuilder();r.Append(GetName());r.Append(" <");r.Append(GetEmailAddress());r.Append("> ");r.Append(when / 1000);r.Append(' ');AppendTimezone(r);return r.ToString();}
// Original:
public static FontCharset valueOf(int value){if(value >= _table.length)return null;return _table[value];}

// Translation:
public static FontCharset ValueOf(int value){if(value>=0&&value<=255)return _table[value];return null;}
// Original:
public NLPSentenceDetectorOp() {sentenceSplitter = null;}

// Translation:
public NLPSentenceDetectorOp(){sentenceSplitter = null;}
// Original:
public String resource() {return this.resource;}

// Translation:
public override void Validate(){base.Validate();}
// Original:
public QueryScorer(Query query, String field) {init(query, field, null, true);}

// Translation:
public QueryScorer(Query query, string field){Init(query, field, null, true);}
// Original:
public ActiveTrustedSigners(java.util.List<Signer> items) {setItems(items);}

// Translation:
public ActiveTrustedSigners(List<Signer> items){_items = items;}
// Original:
public final String toString() {StringBuilder sb = new StringBuilder();sb.append(getClass().getName());sb.append(" [");sb.append(formatReferenceAsString());sb.append("]");return sb.toString();}

// Translation:
public override String ToString(){StringBuilder sb = new StringBuilder();sb.Append(GetType().Name);sb.Append(" [");sb.Append(FormatReferenceAsString());sb.Append("]");return sb.ToString();}
// Original:
public UpdateNodegroupConfigResult updateNodegroupConfig(UpdateNodegroupConfigRequest request) {request = beforeClientExecution(request);return executeUpdateNodegroupConfig(request);}

// Translation:
public virtual UpdateNodegroupConfigResponse UpdateNodegroupConfig(UpdateNodegroupConfigRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateNodegroupConfigRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateNodegroupConfigResponseUnmarshaller.Instance;return Invoke<UpdateNodegroupConfigResponse>(request, options);}
// Original:
public void fill(int fromIndex, int toIndex, long val) {assert val <= maxValue(getBitsPerValue());assert fromIndex <= toIndex;for (int i = fromIndex; i < toIndex; ++i) {set(i, val);}}

// Translation:
public virtual void Fill(int fromIndex, int toIndex, long val){Debug.Assert(val <= MaxValue(BitsPerValue));Debug.Assert(fromIndex <= toIndex);for (int i = fromIndex; i < toIndex; ++i){Set(i, val);}}
// Original:
public ListTrainingJobsResult listTrainingJobs(ListTrainingJobsRequest request) {request = beforeClientExecution(request);return executeListTrainingJobs(request);}

// Translation:
public virtual ListTrainingJobsResponse ListTrainingJobs(ListTrainingJobsRequest request){var options = new InvokeOptions();options.RequestMarshaller = ListTrainingJobsRequestMarshaller.Instance;options.ResponseUnmarshaller = ListTrainingJobsResponseUnmarshaller.Instance;return Invoke<ListTrainingJobsResponse>(request, options);}
// Original:
public DescribeProfilingGroupResult describeProfilingGroup(DescribeProfilingGroupRequest request) {request = beforeClientExecution(request);return executeDescribeProfilingGroup(request);}

// Translation:
public virtual DescribeProfilingGroupResponse DescribeProfilingGroup(DescribeProfilingGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeProfilingGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeProfilingGroupResponseUnmarshaller.Instance;return Invoke<DescribeProfilingGroupResponse>(request, options);}
// Original:
public IgnoreNode(List<FastIgnoreRule> rules) {this.rules = rules;}

// Translation:
public IgnoreNode(IList<IgnoreRule> rules){this.rules = rules;}
// Original:
public static void fill(char[] array, char value) {for (int i = 0; i < array.length; i++) {array[i] = value;}}

// Translation:
public static void fill(char[] array, char value){{for (int i = 0; i < array.Length; i++){array[i] = value;}}}
// Original:
public GetTransitGatewayMulticastDomainAssociationsResult getTransitGatewayMulticastDomainAssociations(GetTransitGatewayMulticastDomainAssociationsRequest request) {request = beforeClientExecution(request);return executeGetTransitGatewayMulticastDomainAssociations(request);}

// Translation:
public virtual GetTransitGatewayMulticastDomainAssociationsResponse GetTransitGatewayMulticastDomainAssociations(GetTransitGatewayMulticastDomainAssociationsRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetTransitGatewayMulticastDomainAssociationsRequestMarshaller.Instance;options.ResponseUnmarshaller = GetTransitGatewayMulticastDomainAssociationsResponseUnmarshaller.Instance;return Invoke<GetTransitGatewayMulticastDomainAssociationsResponse>(request, options);}
// Original:
public LongBuffer compact() {System.arraycopy(backingArray, position + offset, backingArray, offset, remaining());position = limit - position;limit = capacity;mark = UNSET_MARK;return this;}

// Translation:
public override java.nio.LongBuffer compact(){System.Array.Copy(backingArray, _position + offset, backingArray, offset, remaining());_position = _limit - _position;_limit = _capacity;_mark = UNSET_MARK;return this;}
// Original:
public GetCelebrityInfoResult getCelebrityInfo(GetCelebrityInfoRequest request) {request = beforeClientExecution(request);return executeGetCelebrityInfo(request);}

// Translation:
public virtual GetCelebrityInfoResponse GetCelebrityInfo(GetCelebrityInfoRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetCelebrityInfoRequestMarshaller.Instance;options.ResponseUnmarshaller = GetCelebrityInfoResponseUnmarshaller.Instance;return Invoke<GetCelebrityInfoResponse>(request, options);}
// Original:
public GetTranscriptResult getTranscript(GetTranscriptRequest request) {request = beforeClientExecution(request);return executeGetTranscript(request);}

// Translation:
public virtual GetTranscriptResponse GetTranscript(GetTranscriptRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetTranscriptRequestMarshaller.Instance;options.ResponseUnmarshaller = GetTranscriptResponseUnmarshaller.Instance;return Invoke<GetTranscriptResponse>(request, options);}
// Original:
public DeleteCacheParameterGroupResult deleteCacheParameterGroup(DeleteCacheParameterGroupRequest request) {request = beforeClientExecution(request);return executeDeleteCacheParameterGroup(request);}

// Translation:
public virtual DeleteCacheParameterGroupResponse DeleteCacheParameterGroup(DeleteCacheParameterGroupRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteCacheParameterGroupRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteCacheParameterGroupResponseUnmarshaller.Instance;return Invoke<DeleteCacheParameterGroupResponse>(request, options);}
// Original:
public DescribeTagsRequest(java.util.List<Filter> filters) {setFilters(filters);}

// Translation:
public DescribeTagsRequest(List<Filter> filters){_filters = filters;}
// Original:
public CreateCustomMetadataResult createCustomMetadata(CreateCustomMetadataRequest request) {request = beforeClientExecution(request);return executeCreateCustomMetadata(request);}

// Translation:
public virtual CreateCustomMetadataResponse CreateCustomMetadata(CreateCustomMetadataRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateCustomMetadataRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateCustomMetadataResponseUnmarshaller.Instance;return Invoke<CreateCustomMetadataResponse>(request, options);}
// Original:
public Cluster resumeCluster(ResumeClusterRequest request) {request = beforeClientExecution(request);return executeResumeCluster(request);}

// Translation:
public virtual ResumeClusterResponse ResumeCluster(ResumeClusterRequest request){var options = new InvokeOptions();options.RequestMarshaller = ResumeClusterRequestMarshaller.Instance;options.ResponseUnmarshaller = ResumeClusterResponseUnmarshaller.Instance;return Invoke<ResumeClusterResponse>(request, options);}
// Original:
public DescribeMovingAddressesResult describeMovingAddresses(DescribeMovingAddressesRequest request) {request = beforeClientExecution(request);return executeDescribeMovingAddresses(request);}

// Translation:
public virtual DescribeMovingAddressesResponse DescribeMovingAddresses(DescribeMovingAddressesRequest request){var options = new InvokeOptions();options.RequestMarshaller = DescribeMovingAddressesRequestMarshaller.Instance;options.ResponseUnmarshaller = DescribeMovingAddressesResponseUnmarshaller.Instance;return Invoke<DescribeMovingAddressesResponse>(request, options);}
// Original:
public SearchAddressBooksResult searchAddressBooks(SearchAddressBooksRequest request) {request = beforeClientExecution(request);return executeSearchAddressBooks(request);}

// Translation:
public virtual SearchAddressBooksResponse SearchAddressBooks(SearchAddressBooksRequest request){var options = new InvokeOptions();options.RequestMarshaller = SearchAddressBooksRequestMarshaller.Instance;options.ResponseUnmarshaller = SearchAddressBooksResponseUnmarshaller.Instance;return Invoke<SearchAddressBooksResponse>(request, options);}
// Original:
public UpdateDomainToDomainGroupRequest() {super("Domain", "2018-01-29", "UpdateDomainToDomainGroup");setMethod(MethodType.POST);}

// Translation:
public UpdateDomainToDomainGroupRequest(): base("Domain", "2018-01-29", "UpdateDomainToDomainGroup"){Method = MethodType.POST;}
// Original:
public void add(RevCommit c) {Block b = tail;if (b == null) {b = free.newBlock();b.add(c);head = b;tail = b;return;} else if (b.isFull()) {b = free.newBlock();tail.next = b;tail = b;}b.add(c);}

// Translation:
public override void Add(RevCommit c){BlockRevQueue.Block b = tail;if (b == null){b = free.NewBlock();b.Add(c);head = b;tail = b;return;}else{if (b.IsFull()){b = free.NewBlock();tail.next = b;tail = b;}}b.Add(c);}
// Original:
public FloatBuffer put(int index, float c) {checkIndex(index);byteBuffer.putFloat(index * SizeOf.FLOAT, c);return this;}

// Translation:
public override java.nio.FloatBuffer put(int index, float c){checkIndex(index);byteBuffer.putFloat(index * libcore.io.SizeOf.FLOAT, c);return this;}
// Original:
public void flush() throws IOException {try {beginWrite();dst.flush();} catch (InterruptedIOException e) {throw writeTimedOut(e);} finally {endWrite();}}

// Translation:
public override void Flush(){try{BeginWrite();dst.Flush();}catch (ThreadInterruptedException){throw WriteTimedOut();}finally{EndWrite();}}
// Original:
public Set<String> getModified() {return Collections.unmodifiableSet(diff.getModified());}

// Translation:
public virtual ICollection<string> GetModified(){return Sharpen.Collections.UnmodifiableSet(diff.GetModified());}
// Original:
public LongsRef next(int count) throws IOException {assert count > 0;if (ord == valueCount) {throw new EOFException();}if (off == blockSize) {refill();}count = Math.min(count, blockSize - off);count = (int) Math.min(count, valueCount - ord);valuesRef.offset = off;valuesRef.length = count;off += count;ord += count;return valuesRef;}

// Translation:
public Int64sRef Next(int count){Debug.Assert(count > 0);if (ord == valueCount){throw new System.IO.EndOfStreamException();}if (off == blockSize){Refill();}count = Math.Min(count, blockSize - off);count = (int)Math.Min(count, valueCount - ord);valuesRef.Offset = off;valuesRef.Length = count;off += count;ord += count;return valuesRef;}
// Original:
public ByteBuffer slice() {return new ReadOnlyHeapByteBuffer(backingArray, remaining(), offset + position);}

// Translation:
public override java.nio.ByteBuffer slice(){return new java.nio.ReadOnlyHeapByteBuffer(backingArray, remaining(), offset + _position);}
// Original:
public final boolean isEmpty() {return beginA == endA && beginB == endB;}

// Translation:
public bool IsEmpty(){return beginA == endA && beginB == endB;}
// Original:
public static final int commitMessage(byte[] b, int ptr) {final int sz = b.length;if (ptr == 0)ptr += 46; while (ptr < sz && b[ptr] == 'p')ptr += 48; return tagMessage(b, ptr);}

// Translation:
public static int CommitMessage(byte[] b, int ptr){int sz = b.Length;if (ptr == 0){ptr += 46;}while (ptr < sz && b[ptr] == 'p'){ptr += 48;}return TagMessage(b, ptr);}
// Original:
public ValueEval evaluate(ValueEval[] args, OperationEvaluationContext ec) {if (args.length != 2) {return ErrorEval.VALUE_INVALID;}try {double startDateAsNumber = getValue(args[0]);int offsetInMonthAsNumber = (int) getValue(args[1]);Date startDate = DateUtil.getJavaDate(startDateAsNumber);if (startDate == null) {return ErrorEval.VALUE_INVALID;}Calendar calendar = LocaleUtil.getLocaleCalendar();calendar.setTime(startDate);calendar.add(Calendar.MONTH, offsetInMonthAsNumber);return new NumberEval(DateUtil.getExcelDate(calendar.getTime()));} catch (EvaluationException e) {return e.getErrorEval();}}

// Translation:
public ValueEval Evaluate(ValueEval[] args, OperationEvaluationContext ec){double result;if (args.Length != 2){return ErrorEval.VALUE_INVALID;}try{double startDateAsNumber = GetValue(args[0]);int offsetInMonthAsNumber = (int)GetValue(args[1]);DateTime startDate = DateUtil.GetJavaDate(startDateAsNumber);DateTime resultDate = startDate.AddMonths(offsetInMonthAsNumber);result = DateUtil.GetExcelDate(resultDate);NumericFunction.CheckValue(result);return new NumberEval(result);}catch (EvaluationException e){return e.GetErrorEval();}}
// Original:
public DeleteSuggesterResult deleteSuggester(DeleteSuggesterRequest request) {request = beforeClientExecution(request);return executeDeleteSuggester(request);}

// Translation:
public virtual DeleteSuggesterResponse DeleteSuggester(DeleteSuggesterRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteSuggesterRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteSuggesterResponseUnmarshaller.Instance;return Invoke<DeleteSuggesterResponse>(request, options);}
// Original:
public CreatePipelineResult createPipeline(CreatePipelineRequest request) {request = beforeClientExecution(request);return executeCreatePipeline(request);}

// Translation:
public virtual CreatePipelineResponse CreatePipeline(CreatePipelineRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreatePipelineRequestMarshaller.Instance;options.ResponseUnmarshaller = CreatePipelineResponseUnmarshaller.Instance;return Invoke<CreatePipelineResponse>(request, options);}
// Original:
public StopDeliveryStreamEncryptionResult stopDeliveryStreamEncryption(StopDeliveryStreamEncryptionRequest request) {request = beforeClientExecution(request);return executeStopDeliveryStreamEncryption(request);}

// Translation:
public virtual StopDeliveryStreamEncryptionResponse StopDeliveryStreamEncryption(StopDeliveryStreamEncryptionRequest request){var options = new InvokeOptions();options.RequestMarshaller = StopDeliveryStreamEncryptionRequestMarshaller.Instance;options.ResponseUnmarshaller = StopDeliveryStreamEncryptionResponseUnmarshaller.Instance;return Invoke<StopDeliveryStreamEncryptionResponse>(request, options);}
// Original:
public DeleteApplicationSnapshotResult deleteApplicationSnapshot(DeleteApplicationSnapshotRequest request) {request = beforeClientExecution(request);return executeDeleteApplicationSnapshot(request);}

// Translation:
public virtual DeleteApplicationSnapshotResponse DeleteApplicationSnapshot(DeleteApplicationSnapshotRequest request){var options = new InvokeOptions();options.RequestMarshaller = DeleteApplicationSnapshotRequestMarshaller.Instance;options.ResponseUnmarshaller = DeleteApplicationSnapshotResponseUnmarshaller.Instance;return Invoke<DeleteApplicationSnapshotResponse>(request, options);}
// Original:
public ApplyCommand apply() {return new ApplyCommand(repo);}

// Translation:
public virtual ApplyCommand Apply(){return new ApplyCommand(repo);}
// Original:
public RebootCacheClusterRequest(String cacheClusterId, java.util.List<String> cacheNodeIdsToReboot) {setCacheClusterId(cacheClusterId);setCacheNodeIdsToReboot(cacheNodeIdsToReboot);}

// Translation:
public RebootCacheClusterRequest(string cacheClusterId, List<string> cacheNodeIdsToReboot){_cacheClusterId = cacheClusterId;_cacheNodeIdsToReboot = cacheNodeIdsToReboot;}
// Original:
public ModifyCacheClusterRequest(String cacheClusterId) {setCacheClusterId(cacheClusterId);}

// Translation:
public ModifyCacheClusterRequest(string cacheClusterId){_cacheClusterId = cacheClusterId;}
// Original:
public boolean equals(Object obj) {if (this == obj) return true;if (obj == null) return false;if (getClass() != obj.getClass()) return false;ScoreTerm other = (ScoreTerm) obj;if (term == null) {if (other.term != null) return false;} else if (!term.bytesEquals(other.term)) return false;return true;}

// Translation:
public override bool Equals(object obj){if (this == obj){return true;}if (obj == null){return false;}if (this.GetType() != obj.GetType()){return false;}ScoreTerm other = (ScoreTerm)obj;if (Term == null){if (other.Term != null){return false;}}else if (!Term.BytesEquals(other.Term)){return false;}return true;}
// Original:
public AssociateTransitGatewayMulticastDomainResult associateTransitGatewayMulticastDomain(AssociateTransitGatewayMulticastDomainRequest request) {request = beforeClientExecution(request);return executeAssociateTransitGatewayMulticastDomain(request);}

// Translation:
public virtual AssociateTransitGatewayMulticastDomainResponse AssociateTransitGatewayMulticastDomain(AssociateTransitGatewayMulticastDomainRequest request){var options = new InvokeOptions();options.RequestMarshaller = AssociateTransitGatewayMulticastDomainRequestMarshaller.Instance;options.ResponseUnmarshaller = AssociateTransitGatewayMulticastDomainResponseUnmarshaller.Instance;return Invoke<AssociateTransitGatewayMulticastDomainResponse>(request, options);}
// Original:
public UpdateContactResult updateContact(UpdateContactRequest request) {request = beforeClientExecution(request);return executeUpdateContact(request);}

// Translation:
public virtual UpdateContactResponse UpdateContact(UpdateContactRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateContactRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateContactResponseUnmarshaller.Instance;return Invoke<UpdateContactResponse>(request, options);}
// Original:
public TableRecord(CellRangeAddress8Bit range) {super(range);field_6_res = 0;}

// Translation:
public TableRecord(CellRangeAddress8Bit range): base(range){field_6_res = 0;}
// Original:
public CreateProcessingJobResult createProcessingJob(CreateProcessingJobRequest request) {request = beforeClientExecution(request);return executeCreateProcessingJob(request);}

// Translation:
public virtual CreateProcessingJobResponse CreateProcessingJob(CreateProcessingJobRequest request){var options = new InvokeOptions();options.RequestMarshaller = CreateProcessingJobRequestMarshaller.Instance;options.ResponseUnmarshaller = CreateProcessingJobResponseUnmarshaller.Instance;return Invoke<CreateProcessingJobResponse>(request, options);}
// Original:
public CharSequence subSequence(int start, int end) {checkStartEndRemaining(start, end);CharSequenceAdapter result = copy(this);result.position = position + start;result.limit = position + end;return result;}

// Translation:
public override java.lang.CharSequence SubSequence(int start, int end){checkStartEndRemaining(start, end);java.nio.CharSequenceAdapter result = copy(this);result._position = _position + start;result._limit = _position + end;return result;}
// Original:
public GetCoipPoolUsageResult getCoipPoolUsage(GetCoipPoolUsageRequest request) {request = beforeClientExecution(request);return executeGetCoipPoolUsage(request);}

// Translation:
public virtual GetCoipPoolUsageResponse GetCoipPoolUsage(GetCoipPoolUsageRequest request){var options = new InvokeOptions();options.RequestMarshaller = GetCoipPoolUsageRequestMarshaller.Instance;options.ResponseUnmarshaller = GetCoipPoolUsageResponseUnmarshaller.Instance;return Invoke<GetCoipPoolUsageResponse>(request, options);}
// Original:
public UpdateResolverEndpointResult updateResolverEndpoint(UpdateResolverEndpointRequest request) {request = beforeClientExecution(request);return executeUpdateResolverEndpoint(request);}

// Translation:
public virtual UpdateResolverEndpointResponse UpdateResolverEndpoint(UpdateResolverEndpointRequest request){var options = new InvokeOptions();options.RequestMarshaller = UpdateResolverEndpointRequestMarshaller.Instance;options.ResponseUnmarshaller = UpdateResolverEndpointResponseUnmarshaller.Instance;return Invoke<UpdateResolverEndpointResponse>(request, options);}
// Original:
public ValueEval evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0) {ValueEval veText;try {veText = OperandResolver.getSingleValue(arg0, srcRowIndex, srcColumnIndex);} catch (EvaluationException e) {return e.getErrorEval();}String strText = OperandResolver.coerceValueToString(veText);Double result = convertTextToNumber(strText);if(result == null) result = parseDateTime(strText);if (result == null) {return ErrorEval.VALUE_INVALID;}return new NumberEval(result.doubleValue());}

// Translation:
public override ValueEval Evaluate(int srcRowIndex, int srcColumnIndex, ValueEval arg0){ValueEval veText;try{veText = OperandResolver.GetSingleValue(arg0, srcRowIndex, srcColumnIndex);}catch (EvaluationException e){return e.GetErrorEval();}String strText = OperandResolver.CoerceValueToString(veText);Double result = ConvertTextToNumber(strText);if (Double.IsNaN(result)){return ErrorEval.VALUE_INVALID;}return new NumberEval(result);}