public ProteinSpectrumMatchSet[][] GroupAcrossRuns(List<ProteinSpectrumMatchSet>[] prsmGroup, INodeComparer<ProteinSpectrumMatchSet> prsmGroupComparer) { var nDataset = prsmGroup.Length; var prsmSet = new NodeSet<ProteinSpectrumMatchSet>() { }; for (var i = 0; i < nDataset; i++) { var groupedPrsms = prsmGroup[i]; if (groupedPrsms == null) continue; prsmSet.AddRange(groupedPrsms); } var alignedPrsms = prsmSet.ConnnectedComponents(prsmGroupComparer); var alignedResult = new ProteinSpectrumMatchSet[alignedPrsms.Count][]; for (var i = 0; i < alignedResult.Length; i++) alignedResult[i] = new ProteinSpectrumMatchSet[nDataset]; for(var i = 0; i < alignedPrsms.Count; i++) { foreach (var set in alignedPrsms[i]) { if (alignedResult[i][set.DataId] != null) { alignedResult[i][set.DataId].Merge(set); //Console.WriteLine("[{4}] {0}-{1}...{2}-{3}", set.MinScanNum, set.MaxScanNum, alignedResult[i][set.DataId].MinScanNum, alignedResult[i][set.DataId].MaxScanNum, set.DataId); } else { alignedResult[i][set.DataId] = set; } } } return alignedResult; }
public List<ProteinSpectrumMatchSet> GroupingByPrsm(int dataid, IEnumerable<ProteinSpectrumMatch> matches, INodeComparer<ProteinSpectrumMatch> prsmComparer) { var prsmSet = new NodeSet<ProteinSpectrumMatch>(){}; prsmSet.AddRange(matches); var groupList = prsmSet.ConnnectedComponents(prsmComparer); return groupList.Select(@group => new ProteinSpectrumMatchSet(dataid, @group)).ToList(); }
public byte[] GetMove(byte[] initialState, int moveCount) { NodeSet nodeSet = new NodeSet(); for (int i = 0; i < initialState.Length; i++) { applyAvailableMoves(initialState, i, moveCount, nodeSet); } return initialState; }
// Constructor // public NeuralNetwork(string Name, NodeLinkMaster Links, NodeSet Nodes, ResponseNodeSet Responses, NeuralRule Rule, Matrix Data) { // Set values // this._Links = Links; this._Nodes = Nodes; this._Responses = Responses; this._Rule = Rule; this._Data = Data; this._name = Name; // Initialize // this.Initialize(); }
void handlePawn(byte[] state, int position, int moveCount, NodeSet nodeSet) { // for opening move, player can move two spaces if (moveCount == 0) { movePieceIfConstraintMet(state, position, 0, 2, Pieces.Empty, nodeSet); } movePieceIfConstraintMet(state, position, 0, 1, Pieces.Empty, nodeSet); // opponent to the left movePieceIfConstraintMet(state, position, -1, 1, new byte[] { Pieces.Pawn, Pieces.Castle, Pieces.Rook, Pieces.Bishop, Pieces.Queen }, nodeSet); // opponent to the right movePieceIfConstraintMet(state, position, -1, 1, new byte[] { Pieces.Pawn, Pieces.Castle, Pieces.Rook, Pieces.Bishop, Pieces.Queen }, nodeSet); }
public NodeServer(Network network, ProtocolVersion version = ProtocolVersion.PROTOCOL_VERSION, int internalPort = -1) { AdvertizeMyself = true; internalPort = internalPort == -1 ? network.DefaultPort : internalPort; _LocalEndpoint = new IPEndPoint(IPAddress.Parse("0.0.0.0").MapToIPv6(), internalPort); _Network = network; _ExternalEndpoint = new IPEndPoint(_LocalEndpoint.Address, Network.DefaultPort); _Version = version; var listener = new EventLoopMessageListener<IncomingMessage>(ProcessMessage); _MessageProducer.AddMessageListener(listener); OwnResource(listener); RegisterPeerTableRepository(_PeerTable); _Nodes = new NodeSet(); _Nodes.MessageProducer.AddMessageListener(listener); _Trace = new TraceCorrelation(NodeServerTrace.Trace, "Node server listening on " + LocalEndpoint); }
/// <summary> /// Adds the resultant state of a piece move if a contraint is met /// </summary> bool movePieceIfConstraintMet(byte[] state, int position, int dx, int dy, byte pieceMatch, NodeSet nodeSet) { var tx = (position % 8 + dx); var ty = (position / 8) + dy; if ((tx < 0) || (tx >= 8) || (ty < 0) || (ty >= 8)) { return false; } // todo: check self or other player if (state[ty * 8 + tx] != pieceMatch) { return false; } nodeSet.AddNode( state, new int[2] { position, ty * 8 + tx }, new byte[2] { Pieces.Empty, state[position] }); return true; }
public static IEnumerable <Node> Parse(params String[] paths) { var roots = new NodeSet(); foreach (var path in paths) { var pathSplit = path.Split('\\'); Node current = null; foreach (var pathElement in pathSplit) { var currentRoots = (current == null) ? roots : current.Children; if (currentRoots.Contains(pathElement)) { current = currentRoots[pathElement]; } else { current = new Node(pathElement); currentRoots.Add(current); } } } return(roots); }
void applyAvailableMoves(byte[] state, int position, int moveCount, NodeSet nodeSet) { switch (state[position]) { case Pieces.Pawn: handlePawn(state, position, moveCount, nodeSet); break; case Pieces.Castle: break; case Pieces.Rook: break; case Pieces.Bishop: break; case Pieces.King: break; case Pieces.Queen: break; } }
public void TestGenericType <T>(int testBufferSize, T testValue) where T : struct { using (var set = new NodeSet()) { var output = set.Create <GenericOutput <T> >(); var input = set.Create <GenericInput <T> >(); set.SetBufferSize(output, GenericOutput <T> .KernelPorts.Output, Buffer <T> .SizeRequest(testBufferSize)); set.Connect(output, GenericOutput <T> .KernelPorts.Output, input, GenericInput <T> .KernelPorts.Input); set.SendMessage(output, GenericOutput <T> .SimulationPorts.Input, testValue); var value = set.CreateGraphValue(input, GenericInput <T> .KernelPorts.Output); set.Update(); set.DataGraph.SyncAnyRendering(); Assert.AreEqual(testValue, set.GetValueBlocking(value)); set.ReleaseGraphValue(value); set.Destroy(input, output); } }
protected override void ComputeValues(NodeSet NS, int j0, int Len, MultidimensionalArray output) { LevelSet LevSet = (LevelSet)(this.m_owner.GetLevSet()); var BasisHessian = LevSet.Basis.Evaluate2ndDeriv(NS); Debug.Assert(output.GetLength(0) == Len); int N = LevSet.Basis.Length; Debug.Assert(BasisHessian.GetLength(1) == N); int D = this.m_owner.m_owner.GridDat.SpatialDimension; Debug.Assert(D == BasisHessian.GetLength(2)); Debug.Assert(D == BasisHessian.GetLength(3)); Debug.Assert(D == output.GetLength(2)); Debug.Assert(D == output.GetLength(3)); int K = output.GetLength(1); // No of nodes Debug.Assert(K == BasisHessian.GetLength(0)); var Coordinates = ((MultidimensionalArray)LevSet.Coordinates).ExtractSubArrayShallow(new int[] { j0, 0 }, new int[] { j0 + Len - 1, N - 1 }); output.Multiply(1.0, BasisHessian, Coordinates, 0.0, "jkdr", "kndr", "jn"); }
public void EvaluateGradient(int j0, int Len, NodeSet NS, MultidimensionalArray result) { MultidimensionalArray nodes = GetGlobalNodes(j0, Len, NS); int noOfNodes = nodes.GetLength(1); for (int i = 0; i < Len; i++) { for (int j = 0; j < noOfNodes; j++) { double x = nodes[i, j, 0]; double y = nodes[i, j, 1]; double theta = Math.Atan2(y, x); double r = Math.Sqrt(x * x + y * y); //if (r < 0.001) { // result[i, j, 0] = 0.0; // result[i, j, 1] = 0.0; //} else { result[i, j, 0] = -2.5 * Math.Sin(5.0 * theta) * (theta - x * y / r / r) - x / r; result[i, j, 1] = 2.5 * Math.Sin(5.0 * theta) * y * y / r / r - y / r; //} } } }
public void EvaluateGradient(int j0, int Len, NodeSet Ns, MultidimensionalArray result) { MultidimensionalArray nodes = GetGlobalNodes(j0, Len, Ns); int noOfNodes = nodes.GetLength(1); double aSquare = xMajor * xMajor / 4.0; double bSquare = yMajor * yMajor / 4.0; double cSquare = zMajor * zMajor / 4.0; for (int i = 0; i < Len; i++) { for (int j = 0; j < noOfNodes; j++) { double x = nodes[i, j, 0]; double y = nodes[i, j, 1]; double z = nodes[i, j, 2]; double d = Math.Sqrt(x * x / aSquare + y * y / bSquare + z * z / cSquare); result[i, j, 0] = -x / aSquare / d; result[i, j, 1] = -y / bSquare / d; result[i, j, 2] = -z / cSquare / d; } } }
public void EvaluateTotalCurvature(int j0, int Len, NodeSet Ns, MultidimensionalArray result) { MultidimensionalArray nodes = GetGlobalNodes(j0, Len, Ns); int noOfNodes = nodes.GetLength(1); for (int i = 0; i < Len; i++) { for (int j = 0; j < noOfNodes; j++) { double x = nodes[i, j, 0]; double y = nodes[i, j, 1]; double norm = Math.Sqrt(x * x + y * y); // Small perturbation at the singularity if (norm == 0) { norm = 1e-15; } result[i, j] = -1 / norm; } } }
private static bool cmpQueryQueryE(Operator.Op op, object val1, object val2) { bool flag = op == Operator.Op.EQ; NodeSet set = new NodeSet(val1); NodeSet set2 = new NodeSet(val2); while (set.MoveNext()) { if (!set2.MoveNext()) { return(false); } string str = set.Value; do { if ((str == set2.Value) == flag) { return(true); } }while (set2.MoveNext()); set2.Reset(); } return(false); }
void Start() { using (var set = new NodeSet()) { var writer = set.Create <MyWriter>(); var reader = set.Create <MyReader>(); set.Connect(writer, MyWriter.KernelPorts.OutputBuffer, reader, MyReader.KernelPorts.InputBuffer); /* * You'll notice we haven't declared the size of the array anywhere yet. * This is done in the simulation (or externally), by transferring a size request in the SetBufferSize() API * on the node set. */ set.SetBufferSize(writer, MyWriter.KernelPorts.OutputBuffer, Buffer <float> .SizeRequest(50)); set.Update(); /* * Buffer memory is otherwise managed by the node set, so we don't have to worry about cleaning that up. */ set.Destroy(writer, reader); } }
MultidimensionalArray StokesAnsatzRHS(Basis TestBasis, CellBoundaryQuadratureScheme cellBndSchme, CellMask _mask, int order) { var GridDat = this.tracker.GridDat; CellBoundaryQuadrature <CellBoundaryQuadRule> qBnd = null; int N = TestBasis.Length; int D = GridDat.SpatialDimension; MultidimensionalArray RHS = MultidimensionalArray.Create(D, N, _mask.NoOfItemsLocally); double[] CellN = new double[D]; // cell normal double[] SurfN = new double[D]; // level-set normal double[] OutwardTang = new double[D]; // level-set tangent, outward of cell if (D != 2) { throw new NotSupportedException("Currently only supported for spatial dimension of 2."); } //MultidimensionalArray Nudes = null; int jSgrd = 0; qBnd = CellBoundaryQuadrature <CellBoundaryQuadRule> .GetQuadrature(new int[] { D, N }, GridDat, cellBndSchme.Compile(GridDat, order), delegate(int i0, int Length, CellBoundaryQuadRule NS, MultidimensionalArray EvalResult) { // Evaluate //MultidimensionalArray BasisValues = TestBasis.Evaluate(0); // reference //var LSNormals = LsTrk.GetLevelSetReferenceNormals(iLevSet, 0, i0, Length); // reference MultidimensionalArray BasisValues = TestBasis.CellEval(NS.Nodes, i0, Length); // physical MultidimensionalArray LSNormals = this.LevelSetData.GetLevelSetNormals(NS.Nodes, i0, Length); // physical for (int i = 0; i < Length; i++) // loop over cells //if(i0 + i == 1) { // EvalResult.ExtractSubArrayShallow(i, -1, -1, -1).Clear(); // continue; //} { CellBoundaryQuadRule cR = qBnd.CurrentRule; int[] NodesPerEdge = cR.NumbersOfNodesPerFace; var Kref = cR.RefElement; int NoOfFaces = Kref.NoOfFaces; int iNode = 0; Debug.Assert(NoOfFaces == NodesPerEdge.Length); for (int e = 0; e < NoOfFaces; e++) // loop over the faces of the cell { if (NodesPerEdge[e] <= 0) { continue; } // reference: //for (int d = 0; d < D; d++) { // CellN[d] = Kref.FaceNormals[e, d]; //} // ~~~~ // physical: var FaceNodes = new NodeSet(Kref, cR.Nodes.ExtractSubArrayShallow(new int[] { iNode, 0 }, new int[] { iNode + NodesPerEdge[e] - 1, D - 1 })); var FaceNormals = MultidimensionalArray.Create(NodesPerEdge[e], D); GridDat.Edges.GetNormalsForCell(FaceNodes, i0, e, FaceNormals); // ~~~~ for (int _n = 0; _n < NodesPerEdge[e]; _n++) // loop over nodes in one edge { for (int d = 0; d < D; d++) { SurfN[d] = LSNormals[i, iNode, d]; CellN[d] = FaceNormals[_n, d]; // physical } tangente(SurfN, CellN, OutwardTang); for (int n = 0; n < N; n++) // loop over Test polynomials (the same as the basis polynomials) { for (int d = 0; d < D; d++) // loop over spatial direction { EvalResult[i, iNode, d, n] = BasisValues[i, iNode, n] * OutwardTang[d]; // physical //EvalResult[i, iNode, d, n] = BasisValues[iNode, n]*OutwardTang[d]; // reference } } iNode++; } } Debug.Assert(iNode == EvalResult.GetLength(1)); } }, delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) { // SaveIntegrationResults for (int i = 0; i < Length; i++) { var ResPart = RHS.ExtractSubArrayShallow(new int[] { 0, 0, jSgrd }, new int[] { D - 1, N - 1, jSgrd - 1 }); int NoOfFaces = ResultsOfIntegration.GetLength(1); for (int e = 0; e < NoOfFaces; e++) { var ip = ResultsOfIntegration.ExtractSubArrayShallow(new int[] { i, e, 0, 0 }, new int[] { i - 1, e - 1, D - 1, N - 1 }); ResPart.Acc(1.0, ip); } jSgrd++; } }, cs : CoordinateSystem.Physical); qBnd.Execute(); var ret = RHS.ResizeShallow(N * D, _mask.NoOfItemsLocally); return(ret); }
protected MultidimensionalArray GaußAnsatzRHS(DivergenceFreeBasis TestBasis, CellBoundaryQuadratureScheme cellBndScheme, CellMask _mask, int order) { var _Context = this.tracker.GridDat; int D = this.tracker.GridDat.Grid.SpatialDimension; int N = TestBasis.Count; var coordSys = CoordinateSystem.Reference; var LsTrk = this.tracker; int Nrhs = _mask.NoOfItemsLocally; Debug.Assert(N % D == 0); N /= D; MultidimensionalArray RHS = MultidimensionalArray.Create(N, Nrhs); var splx = this.Kref; int NoOfFaces = splx.NoOfFaces; //var normals = _Context.GridDat.Normals; CellBoundaryQuadrature <CellBoundaryQuadRule> qBnd = null; int jSgrd = 0; qBnd = CellBoundaryQuadrature <CellBoundaryQuadRule> .GetQuadrature(new int[] { N }, _Context, cellBndScheme.Compile(_Context, order), delegate(int i0, int Length, CellBoundaryQuadRule QR, MultidimensionalArray EvalResult) { // Evaluate NodeSet Nodes = QR.Nodes; MultidimensionalArray BasisValues; if (coordSys == CoordinateSystem.Physical) { //BasisValues = TestBasis.CellEval(Nodes, i0, Length); throw new NotImplementedException("todo"); } else if (coordSys == CoordinateSystem.Reference) { BasisValues = TestBasis.Values.GetValues(Nodes); } else { throw new NotImplementedException(); } for (int i = 0; i < Length; i++) // loop over cells { CellBoundaryQuadRule cR = qBnd.CurrentRule; int[] NodesPerEdge = cR.NumbersOfNodesPerFace; Debug.Assert(object.ReferenceEquals(splx, cR.RefElement)); int iNode = 0; Debug.Assert(NoOfFaces == NodesPerEdge.Length); for (int e = 0; e < NoOfFaces; e++) // loop over the faces of the cell { for (int _n = 0; _n < NodesPerEdge[e]; _n++) // loop over nodes in one edge { for (int n = 0; n < N; n++) // loop over Test polynomials (the same as the basis polynomials) { double acc = 0; for (int d = 0; d < D; d++) // loop over spatial directions { if (coordSys == CoordinateSystem.Physical) { throw new NotImplementedException("todo"); //int q = _Context.GridDat.LocalCellIndexToEdges[i+i0, e]; //int iEdge = Math.Abs(q) - 1; //double Nsign = Math.Sign(q); //double Nd = normals[iEdge, d]; //EvalResult[i, iNode, n, d] = BasisValues[i, iNode, n]*Nd*Nsign; } else { Debug.Assert(coordSys == CoordinateSystem.Reference); double Nd = splx.FaceNormals[e, d]; //Debug.Assert(Nd == normals[iEdge, d]*Nsign); acc += BasisValues[iNode, n *D + d] * Nd; } } EvalResult[i, iNode, n] = acc; } iNode++; } } Debug.Assert(iNode == EvalResult.GetLength(1)); } }, delegate(int i0, int Length, MultidimensionalArray ResultsOfIntegration) { // SaveIntegrationResults for (int i = 0; i < Length; i++) { var ResPart = RHS.ExtractSubArrayShallow(new int[] { 0, jSgrd }, new int[] { N - 1, jSgrd - 1 }); for (int e = 0; e < NoOfFaces; e++) { var ip = ResultsOfIntegration.ExtractSubArrayShallow(new int[] { i, e, 0 }, new int[] { i - 1, e - 1, N - 1 }); ResPart.Acc(1.0, ip); } jSgrd++; } }, cs : coordSys); qBnd.Execute(); return(RHS); }
protected MultidimensionalArray GaußAnsatzMatrix(DivergenceFreeBasis TestBasis, NodeSet SurfQrNodes, int jCell) { int N = TestBasis.Count; int D = this.tracker.GridDat.Grid.SpatialDimension; Debug.Assert(N % D == 0); N /= D; int ksurf = SurfQrNodes.GetLength(0); Debug.Assert(SurfQrNodes.Dimension == 2); Debug.Assert(SurfQrNodes.GetLength(1) == D); int iKref = this.tracker.GridDat.Cells.GetRefElementIndex(jCell); MultidimensionalArray EdgMatrix = MultidimensionalArray.Create(N, ksurf); // evaluate Basis and Gradient of Basis var Phi = TestBasis.Values.GetValues(SurfQrNodes); // test function, n var LevelSetNormals = this.LevelSetData.GetLevelSetReferenceNormals(SurfQrNodes, jCell, 1).ExtractSubArrayShallow(0, -1, -1); //metrics = tracker.GetLevelSetNormalReferenceToPhysicalMetrics(this.LevelSetIndex, 0, jCell, 1); // multiply for (int k = 0; k < ksurf; k++) // loop over nodes... { for (int n = 0; n < N; n++) // loop over basis polynomials... { double acc = 0.0; for (int d = 0; d < D; d++) // loop over spatial dimension... { acc += Phi[k, n *D + d] * LevelSetNormals[k, d]; } EdgMatrix[n, k] = acc; } } // resize and return: return(EdgMatrix); }
/// <summary> /// Fill the PeerTable with fresh addresses /// </summary> public void DiscoverPeers(int peerToFind = 990) { TraceCorrelation traceCorrelation = new TraceCorrelation(NodeServerTrace.Trace, "Discovering nodes"); List<Task> tasks = new List<Task>(); using(traceCorrelation.Open()) { while(CountPeerRequired(peerToFind) != 0) { NodeServerTrace.PeerTableRemainingPeerToGet(CountPeerRequired(peerToFind)); CancellationTokenSource cancellation = new CancellationTokenSource(TimeSpan.FromSeconds(40)); var peers = PeerTable.GetActivePeers(1000); if(peers.Length == 0) { PopulateTableWithDNSNodes(); PopulateTableWithHardNodes(); peers = PeerTable.GetActivePeers(1000); } CancellationTokenSource peerTableFull = new CancellationTokenSource(); NodeSet connected = new NodeSet(); try { Parallel.ForEach(peers, new ParallelOptions() { MaxDegreeOfParallelism = 5, CancellationToken = peerTableFull.Token, }, p => { Node n = null; try { n = GetNodeByPeer(p, cancellation.Token); if(n.State < NodeState.HandShaked) { connected.AddNode(n); n.VersionHandshake(cancellation.Token); } n.SendMessage(new GetAddrPayload()); Thread.Sleep(2000); } catch(Exception) { if(n != null) n.Disconnect(); } if(CountPeerRequired(peerToFind) == 0) peerTableFull.Cancel(); else NodeServerTrace.Information("Need " + CountPeerRequired(peerToFind) + " more peers"); }); } catch(OperationCanceledException) { } finally { connected.DisconnectAll(); } } NodeServerTrace.Trace.TraceInformation("Peer table is now full"); } }
static bool cmpQueryBoolO(Operator.Op op, object val1, object val2) { NodeSet n1 = new NodeSet(val1); double d1 = n1.MoveNext() ? 1.0 : 0; double d2 = NumberFunctions.Number((bool)val2); return cmpNumberNumberO(op, d1, d2); }
// Render the network // public NeuralNetwork Construct() { // Create the scrubber // NeuralDataFactory scrubber = new NeuralDataFactory(this._SourceData, this._XValues, this._YValues, this._Where); // Create the data layer // this._DataLayer = new NN_Layer(this._DataBias, scrubber.InputKey, scrubber.Columns); // Create the prediction layer // this._PredictionLayer = new NN_Layer(this._PredictionReducer, this._PredictionActivation, scrubber.OutputKey); // Link predictions to last hidden // if (this._HiddenLayers.Count == 0) { NN_Layer.LinkChildren(this._Links, this._PredictionLayer, this._DataLayer); } else { // Data -> First.Hidden NN_Layer.LinkChildren(this._Links, this._HiddenLayers.First(), this._DataLayer); // Last.Hidden -> Predictions // NN_Layer.LinkChildren(this._Links, this._PredictionLayer, this._HiddenLayers.Last()); // Hidden -> Hidden // for (int i = 0; i < this._HiddenLayers.Count - 1; i++) NN_Layer.LinkChildren(this._Links, this._HiddenLayers[i + 1], this._HiddenLayers[i]); } // Build a nodeset // NodeSet nodes = new NodeSet(this._Links); // Build a response set // ResponseNodeSet responses = new ResponseNodeSet(this._Links); // Neural rule // NeuralRule rule = RuleFactory.Construct(this.DefaultRule, responses); // Construct // return new NeuralNetwork(this._name, this._Links, nodes, responses, rule, scrubber.ScrubbedData); }
private SlashIterator (SlashIterator other) : base (other) { _iterLeft = (BaseIterator) other._iterLeft.Clone (); if (other._iterRight != null) _iterRight = (BaseIterator) other._iterRight.Clone (); _expr = other._expr; if (other._iterList != null) _iterList = (SortedList) other._iterList.Clone (); _finished = other._finished; if (other._nextIterRight != null) _nextIterRight = (BaseIterator) other._nextIterRight.Clone (); }
public SlashIterator (BaseIterator iter, NodeSet expr) : base (iter.NamespaceManager) { _iterLeft = iter; _expr = expr; }
private SimpleSlashIterator (SimpleSlashIterator other) : base (other) { _expr = other._expr; _left = (BaseIterator) other._left.Clone (); if (other._right != null) _right = (BaseIterator) other._right.Clone (); }
public SimpleSlashIterator (BaseIterator left, NodeSet expr) : base (left.NamespaceManager) { this._left = left; this._expr = expr; }
public override Expression Optimize () { left = left.Optimize (); right = (NodeSet) right.Optimize (); // Path A//B is equal to // A/descendant-or-self::node()/child::B, which is // equivalent to A/descendant::B. Unlike '//', '/' // could be optimized by SimpleSlashIterator. NodeTest rnt = right as NodeTest; if (rnt != null && rnt.Axis.Axis == Axes.Child) { NodeNameTest nameTest = rnt as NodeNameTest; if (nameTest != null) return new ExprSLASH (left, new NodeNameTest (nameTest, Axes.Descendant)); NodeTypeTest typeTest = rnt as NodeTypeTest; if (typeTest != null) return new ExprSLASH (left, new NodeTypeTest (typeTest, Axes.Descendant)); } return this; }
public ExprSLASH2 (Expression left, NodeSet right) { this.left = left; this.right = right; }
protected override GridCommons CreateOrLoadGrid() { // Options string dataPath = @"\\fdyprime\userspace\mueller\Jan\waves\"; string databasePath = @"e:\bosss_db\GridOfTomorrow\"; noOfCellsX = 64; noOfNodesPerEdge = 4; dgDegree = 6; //noOfCellsX = 85; //noOfNodesPerEdge = 4; //dgDegree = 6; Directory.SetCurrentDirectory(dataPath); DatabaseInfo database = new DatabaseInfo(databasePath); string sessionDescription = "Blafasel"; // Create the grid aspectRatio = 4; GridCommons grid = Grid2D.Cartesian2DGrid( GenericBlas.Linspace(0.0, 1.0, noOfCellsX + 1), GenericBlas.Linspace(-1.5, 2.5, aspectRatio * noOfCellsX + 1), CellType.Square_Linear, periodicX: true, periodicY: false); grid.EdgeTagNames.Add(1, "subsonicOutlet"); grid.EdgeTagNames.Add(2, "supersonicInlet"); grid.DefineEdgeTags(delegate(double[] x) { if (x[1] > 0.0) { return(2); } else { return(1); } }); gridData = new GridData(grid); // Read the values MultidimensionalArray rho = ReadVariableValues("rho"); MultidimensionalArray u = ReadVariableValues("vx1"); MultidimensionalArray v = ReadVariableValues("vx2"); MultidimensionalArray p = ReadVariableValues("prs"); // Assemble node set corresponding to the ordering from Matlab double[] nodes1D = GenericBlas.Linspace(-1.0, 1.0, noOfNodesPerEdge); int noOfNodesPerCell = noOfNodesPerEdge * noOfNodesPerEdge; double[,] localNodes = new double[noOfNodesPerCell, gridData.SpatialDimension]; for (int i = 0; i < noOfNodesPerEdge; i++) { for (int j = 0; j < noOfNodesPerEdge; j++) { int localNodeIndex = i * noOfNodesPerEdge + j; localNodes[localNodeIndex, 0] = nodes1D[i]; localNodes[localNodeIndex, 1] = nodes1D[j]; } } nodeSet = new NodeSet(gridData.Grid.RefElements[0], localNodes); // Interpolate //SinglePhaseField[] fields = LeastSquaresInterpolation(rho, u, v, p); SinglePhaseField[] fields = SpecFEMInterpolation(rho, u, v, p); // Save everything database.Controller.DBDriver.SaveGrid(grid); SessionInfo session = database.Controller.DBDriver.CreateNewSession(database); session.Description = sessionDescription; session.Save(); database.Controller.DBDriver.SaveTimestep( 0.0, 0, session, gridData, fields); return(grid); }
double EvaluateAt(S Psi, NodeSet Point) { return(EvaluateAt(Psi, Point, this.cell)); }
static bool cmpQueryBoolE(Operator.Op op, object val1, object val2) { NodeSet n1 = new NodeSet(val1); bool b1 = n1.MoveNext(); bool b2 = (bool)val2; return cmpBoolBoolE(op, b1, b2); }
bool HeightDirectionIsSuitable(T arg, S psi, NodeSet Point, int heightDirection, MultidimensionalArray gradient) { return(HeightDirectionIsSuitable(arg, psi, Point, heightDirection, gradient, this.cell)); }
/*cmpXslt:*/ static bool cmpQueryQueryE(Operator.Op op, object val1, object val2) { Debug.Assert(op == Operator.Op.EQ || op == Operator.Op.NE); bool isEQ = (op == Operator.Op.EQ); NodeSet n1 = new NodeSet(val1); NodeSet n2 = new NodeSet(val2); while (true) { if (! n1.MoveNext()) { return false; } if (! n2.MoveNext()) { return false; } string str1 = n1.Value; do { if ((str1 == n2.Value) == isEQ) { return true; } }while (n2.MoveNext()); n2.Reset(); } }
double EvaluateBounds(T arg, S psi, NodeSet x_center) { return(EvaluateBounds(arg, psi, x_center, this.cell)); }
public NodeSet CreateNodeSet(int size) { if(size > 1000) throw new ArgumentOutOfRangeException("size", "size should be less than 1000"); TraceCorrelation trace = new TraceCorrelation(NodeServerTrace.Trace, "Creating node set of size " + size); NodeSet set = new NodeSet(); using(trace.Open()) { while(set.Count() < size) { var peerToGet = size - set.Count(); var activePeers = PeerTable.GetActivePeers(1000); activePeers = activePeers.Where(p => !set.Contains(p.NetworkAddress.Endpoint)).ToArray(); if(activePeers.Length < peerToGet) { DiscoverPeers(size); continue; } NodeServerTrace.Information("Need " + peerToGet + " more nodes"); BlockingCollection<Node> handshakedNodes = new BlockingCollection<Node>(peerToGet); CancellationTokenSource handshakedFull = new CancellationTokenSource(); try { Parallel.ForEach(activePeers, new ParallelOptions() { MaxDegreeOfParallelism = 10, CancellationToken = handshakedFull.Token }, p => { if(set.Contains(p.NetworkAddress.Endpoint)) return; Node node = null; try { node = GetNodeByPeer(p, handshakedFull.Token); node.VersionHandshake(handshakedFull.Token); if(node != null && node.State != NodeState.HandShaked) node.Disconnect(); if(!handshakedNodes.TryAdd(node)) { handshakedFull.Cancel(); node.Disconnect(); } else { var remaining = (size - set.Count() - handshakedNodes.Count); if(remaining == 0) { handshakedFull.Cancel(); } else NodeServerTrace.Information("Need " + remaining + " more nodes"); } } catch(Exception) { if(node != null) node.Disconnect(); } }); } catch(OperationCanceledException) { } set.AddNodes(handshakedNodes.ToArray()); } } return set; }
protected abstract double EvaluateAt(S Psi, NodeSet Point, int cell);
public Model(EndianBinaryReader er) { long basepos = er.BaseStream.Position; size = er.ReadUInt32(); ofsSbc = er.ReadUInt32(); ofsMat = er.ReadUInt32(); ofsShp = er.ReadUInt32(); ofsEvpMtx = er.ReadUInt32(); info = new ModelInfo(er); nodes = new NodeSet(er); long curpos = er.BaseStream.Position; er.BaseStream.Position = ofsSbc + basepos; sbc = er.ReadBytes((int)(ofsMat - ofsSbc)); er.BaseStream.Position = curpos; er.BaseStream.Position = ofsMat + basepos; materials = new MaterialSet(er); er.BaseStream.Position = ofsShp + basepos; shapes = new ShapeSet(er); if (ofsEvpMtx != size && ofsEvpMtx != 0) { er.BaseStream.Position = ofsEvpMtx + basepos; evpMatrices = new EvpMatrices(er, nodes.dict.numEntry); } /*long modelset = er.GetMarker("ModelSet"); er.ClearMarkers(); curpos = er.BaseStream.Position; er.BaseStream.Position = modelset; er.SetMarkerOnCurrentOffset("ModelSet"); er.BaseStream.Position = curpos;*/ }
protected abstract bool HeightDirectionIsSuitable(T arg, S psi, NodeSet Point, int heightDirection, MultidimensionalArray gradient, int cell);
NodeSet ProjectOntoLevset(int jCell, NodeSet Nodes) { int D = Nodes.GetLength(1); int NoOfNodes = Nodes.GetLength(0); var m_Context = this.tracker.GridDat; LevelSet LevSet = (LevelSet)(this.tracker.LevelSets[this.LevelSetIndex]); MultidimensionalArray LevSetValues = MultidimensionalArray.Create(1, NoOfNodes); MultidimensionalArray LevSetGrad = MultidimensionalArray.Create(1, NoOfNodes, D); MultidimensionalArray x0_i_Local = MultidimensionalArray.Create(1, NoOfNodes, D); MultidimensionalArray x0_i_Global = MultidimensionalArray.Create(1, NoOfNodes, D); // quadrature nodes in global coordinates MultidimensionalArray x0_ip1_Local = MultidimensionalArray.Create(1, NoOfNodes, D); MultidimensionalArray x0_ip1_Global = MultidimensionalArray.Create(NoOfNodes, D); // set initial value; x0_i_Local.SetSubArray(Nodes, 0, -1, -1); int NN = NoOfNodes; for (int i = 0; i < 10; i++) { double radiusError = 0; int j = jCell; LevSet.Evaluate(j, 1, Nodes, LevSetValues, 0, 0.0); LevSet.EvaluateGradient(j, 1, Nodes, LevSetGrad); m_Context.TransformLocal2Global(new NodeSet(this.Kref, x0_i_Local.ExtractSubArrayShallow(0, -1, -1)), j, 1, x0_i_Global, 0); for (int nn = 0; nn < NN; nn++) { double sc = 0; for (int d = 0; d < D; d++) { sc += LevSetGrad[0, nn, d].Pow2(); } for (int d = 0; d < D; d++) { double xd = x0_i_Global[0, nn, d] - LevSetGrad[0, nn, d] * LevSetValues[0, nn] / sc; x0_ip1_Global[nn, d] = xd; } radiusError += Math.Abs(LevSetValues[0, nn]); } m_Context.TransformGlobal2Local(x0_ip1_Global, x0_ip1_Local, j, 1, 0); // next iter: x0_i <- x0_{i+1} x0_i_Local.Set(x0_ip1_Local); Nodes = (new NodeSet(this.Kref, x0_i_Local.ExtractSubArrayShallow(0, -1, -1))); } return(Nodes); }
public void AddNode(INode <T> node) { NodeSet.Add(node); }
MultidimensionalArray StokesAnsatzMatrix(Basis TestBasis, NodeSet surfaceNodes, int jCell) { int N = TestBasis.Length; int NoOfNodes = surfaceNodes.GetLength(0); int D = surfaceNodes.GetLength(1); var GridDat = this.tracker.GridDat; Debug.Assert(D == GridDat.SpatialDimension); int iKref = GridDat.Cells.GetRefElementIndex(jCell); var scalings = GridDat.Cells.JacobiDet; int iLevSet = this.LevelSetIndex; if (!GridDat.Cells.IsCellAffineLinear(jCell)) { throw new NotSupportedException(); } //var Phi = TestBasis.Evaluate(0); // reference //var GradPhi = TestBasis.EvaluateGradient(0); // reference var Phi = TestBasis.CellEval(surfaceNodes, jCell, 1).ExtractSubArrayShallow(0, -1, -1); // physical var GradPhi = TestBasis.CellEvalGradient(surfaceNodes, jCell, 1).ExtractSubArrayShallow(0, -1, -1, -1); // physical //var LevsetNormal = this.LsTrk.GetLevelSetReferenceNormals(iLevSet, 0, jCell, 1); // reference //var Curvature = this.LsTrk.GetLevelSetReferenceCurvature(iLevSet, 0, jCell, 1); // reference var LevsetNormal = this.LevelSetData.GetLevelSetNormals(surfaceNodes, jCell, 1).ExtractSubArrayShallow(0, -1, -1); // physical var Curvature = MultidimensionalArray.Create(1, NoOfNodes); // physical ((LevelSet)(this.tracker.LevelSets[iLevSet])).EvaluateTotalCurvature(jCell, 1, surfaceNodes, Curvature); // physical var Coeffs = MultidimensionalArray.Create(D, N, NoOfNodes); if (D == 2) { for (int k = 0; k < NoOfNodes; k++) // loop over nodes { double Nx = LevsetNormal[k, 0]; double Ny = LevsetNormal[k, 1]; double kappa = Curvature[0, k]; double Prj_11 = 1.0 - Nx * Nx, Prj_12 = -Nx * Ny, Prj_21 = -Ny * Nx, Prj_22 = 1.0 - Ny * Ny; for (int n = 0; n < N; n++) { double Phi_kn = Phi[k, n]; double dPhi_dx_kn = GradPhi[k, n, 0]; double dPhi_dy_kn = GradPhi[k, n, 1]; Coeffs[0, n, k] = -Phi_kn * kappa * Nx + Prj_11 * dPhi_dx_kn + Prj_12 * dPhi_dy_kn; Coeffs[1, n, k] = -Phi_kn * kappa * Ny + Prj_21 * dPhi_dx_kn + Prj_22 * dPhi_dy_kn; } } } else if (D == 3) { throw new NotImplementedException("to do."); } else { throw new NotSupportedException("Unknown spatial dimension."); } Coeffs.Scale(scalings[jCell]); // physical return(Coeffs.ResizeShallow(N * D, NoOfNodes)); }
public bool Contains(INode <T> node) { return(NodeSet.Contains(node)); }
//Algorithm 3 //page: A1006 protected void SayeRecursion(TreeNode <T> treeNode) { T arg = treeNode.Value; //Assert ... (line 1) Debug.Assert(arg.Surface == false || (arg.Dimension > 1 && arg.n == 1)); //Check treeNode : Prune //----------------------------------------------------------------------------------------------- // If d = 1 ... (line 2) if (arg.Dimension == 1) { return; } //Define x_c (line 3) NodeSet x_center = arg.GetCellCenter(); //for i = n downto 1 do (line 4) for (int i = arg.n - 1; i >= 0; --i) { Tuple <S, int> psiAndS = arg.PsiAndS[i]; S psi_i = psiAndS.Item1; //Evaluate bounds on the value of psi_i on U such that sup_(x element U)|psi_i(x) - psi_i(x_c)| <= delta (line 5) double delta = EvaluateBounds(arg, psi_i, x_center); // if |psi_i(x_c)| >= delta then (line 6) if (delta <= Math.Abs(EvaluateAt(psi_i, x_center))) { int s_i = psiAndS.Item2; //if s_i * psi_i >= 0 (line 7) if (s_i * EvaluateAt(psi_i, x_center) >= 0) { //Remove ψi from the list and decrement n by one. (line 8) arg.PsiAndS.RemoveAt(i); } else { //The domain of integration is empty; return 0. (line 9,10) arg.Status = SayeArgument <S> .Mode.DomainIsEmpty; return; } } } //if n = 0 then (line 11) if (arg.n == 0) { //If this is a Surface Integral, this Subcell is empty if (arg.Surface) { arg.Status = SayeArgument <S> .Mode.DomainIsEmpty; } else { //Apply a tensor - product Gaussian quadrature scheme (line 12) arg.Status = SayeArgument <S> .Mode.GaussQuadrature; } return; } //Find new subspace //----------------------------------------------------------------------------------------------- //Set k = argmax_j|d_xj Psi_1(x_c)| and initialize Psi-tilde = empty (line 14) S psi_1 = arg.PsiAndS[0].Item1; int k = FindPromisingHeightDirection(psi_1, x_center); T subspaceArg = DeriveNewArgument(arg); //for i = 1 to n do (line 15) foreach (Tuple <S, int> psiAndS in arg.PsiAndS) { S psi_i = psiAndS.Item1; int s_i = psiAndS.Item2; //Evaluate g := gradient(Psi_i(x_c)) (line 16) MultidimensionalArray g = Gradient(psi_i, x_center); //Determine bounds and check bounds (line 17,18) if (HeightDirectionIsSuitable(arg, psi_i, x_center, k, g)) { //Define Psi_i^L and Psi_i^U (line 19) S[] subPsis = ExtractSubPsis(psi_i, arg, k); S psi_U = subPsis[1]; S psi_L = subPsis[0]; //Evaluate signs s_i^L and s_i^U (line 20) int s_U = EvaluateSign(g, k, s_i, arg.Surface, 1); int s_L = EvaluateSign(g, k, s_i, arg.Surface, -1); //Add {Psi_i^L, s_i^L} and {Psi_i^U, s_i^U} to the collection Psi-tilde (line 21) Tuple <S, int> newPsiAndS_U = new Tuple <S, int>(psi_U, s_U); Tuple <S, int> newPsiAndS_L = new Tuple <S, int>(psi_L, s_L); subspaceArg.PsiAndS.Add(newPsiAndS_U); subspaceArg.PsiAndS.Add(newPsiAndS_L); } else { //The height function direction ek is not suitable for ψi. If already subdivided too //many times, revert to a low - order method(see discussion).Otherwise split U (line 23) if (SubdivideSuitable(arg)) { //Subdivide T siblingArg = Subdivide(arg); TreeNode <T> sibling = treeNode.AddSibling(siblingArg); //Recalculate SayeRecursion(treeNode); SayeRecursion(sibling); } else { arg.Status = SayeArgument <S> .Mode.LowOrderQuadrature; } return; } } //Define a new integrand (line 24) arg.HeightDirection = k; //return I(...) (line 25) subspaceArg.Surface = false; subspaceArg.RemoveDimension(k); TreeNode <T> subSpaceNode = treeNode.AddChild(subspaceArg); SayeRecursion(subSpaceNode); }
public override Expression Optimize () { left = left.Optimize (); right = (NodeSet) right.Optimize (); return this; }
int FindPromisingHeightDirection(S psi, NodeSet Point) { return(FindPromisingHeightDirection(psi, Point, this.cell)); }
public override object Clone() { NodeSet copy = new NodeSet(); foreach (object o in this) { copy.Add(o); } return copy; }
MultidimensionalArray Gradient(S psi, NodeSet Node) { return(Gradient(psi, Node, this.cell)); }
/// <summary> /// Exports a node to a nodeset. /// </summary> public void ExportNode(NodeId nodeId, NodeSet nodeSet) { lock (m_lock) { ILocalNode node = GetLocalNode(nodeId) as ILocalNode; if (node == null) { throw ServiceResultException.Create(StatusCodes.BadNodeIdUnknown, "NodeId ({0}) does not exist.", nodeId); } ExportNode(node, nodeSet, (node.NodeClass & (NodeClass.Object | NodeClass.Variable)) != 0); } }
protected abstract MultidimensionalArray Gradient(S psi, NodeSet Node, int Cell);
/// <summary> /// Exports a node to a nodeset. /// </summary> public void ExportNode(ILocalNode node, NodeSet nodeSet, bool instance) { lock (m_lock) { // check if the node has already been added. NodeId exportedId = nodeSet.Export(node.NodeId, m_nodes.NamespaceUris); if (nodeSet.Contains(exportedId)) { return; } // add to nodeset. Node nodeToExport = nodeSet.Add(node, m_nodes.NamespaceUris, m_nodes.ServerUris); // follow children. foreach (ReferenceNode reference in node.References) { // export all references. bool export = true; // unless it is a subtype reference. if (m_server.TypeTree.IsTypeOf(reference.ReferenceTypeId, ReferenceTypeIds.HasSubtype)) { export = false; } if (export) { nodeSet.AddReference(nodeToExport, reference, m_nodes.NamespaceUris, m_nodes.ServerUris); } if (reference.IsInverse || m_server.TypeTree.IsTypeOf(reference.ReferenceTypeId, ReferenceTypeIds.HasSubtype)) { nodeSet.AddReference(nodeToExport, reference, m_nodes.NamespaceUris, m_nodes.ServerUris); } if (m_server.TypeTree.IsTypeOf(reference.ReferenceTypeId, ReferenceTypeIds.Aggregates)) { if (reference.IsInverse) { continue; } ILocalNode child = GetLocalNode(reference.TargetId) as ILocalNode; if (child != null) { if (instance) { NodeId modellingRule = child.ModellingRule; if (modellingRule != Objects.ModellingRule_Mandatory) { continue; } } ExportNode(child, nodeSet, instance); } } } } }
protected abstract int FindPromisingHeightDirection(S psi, NodeSet Point, int cell);
/*cmpXslt:*/ static bool cmpQueryQueryO(Operator.Op op, object val1, object val2) { Debug.Assert( op == Operator.Op.LT || op == Operator.Op.GT || op == Operator.Op.LE || op == Operator.Op.GE ); NodeSet n1 = new NodeSet(val1); NodeSet n2 = new NodeSet(val2); while (true) { if (!n1.MoveNext()) { return false; } if (!n2.MoveNext()) { return false; } double num1 = NumberFunctions.Number(n1.Value); do { if (cmpNumberNumber(op, num1, NumberFunctions.Number(n2.Value))) { return true; } } while (n2.MoveNext()); n2.Reset(); } }
protected abstract double EvaluateBounds(T arg, S psi, NodeSet x_center, int cell);
static bool cmpQueryStringE(Operator.Op op, object val1, object val2) { NodeSet n1 = new NodeSet(val1); string n2 = (string) val2; while (n1.MoveNext()) { if (cmpStringStringE(op, n1.Value, n2)) { return true; } } return false; }
public INode <T> GetNode(T data) { return(NodeSet.FindByValue(data)); }
static bool cmpQueryStringO(Operator.Op op, object val1, object val2) { NodeSet n1 = new NodeSet(val1); double n2 = NumberFunctions.Number((string) val2); while (n1.MoveNext()) { if (cmpNumberNumberO(op, NumberFunctions.Number(n1.Value), n2)) { return true; } } return false; }
public bool Contains(T value) { return(NodeSet.FindByValue(value) != null); }
static bool cmpRtfQueryE(Operator.Op op, object val1, object val2) { string n1 = Rtf(val1); NodeSet n2 = new NodeSet(val2); while (n2.MoveNext()) { if (cmpStringStringE(op, n1, n2.Value)) { return true; } } return false; }
/// <summary> /// modifies a matrix <paramref name="Mtx"/> and a right-hand-side <paramref name="rhs"/> /// in order to fix the pressure at some reference point /// </summary> /// <param name="map">row mapping for <paramref name="Mtx"/> as well as <paramref name="rhs"/></param> /// <param name="iVar">the index of the pressure variable in the mapping <paramref name="map"/>.</param> /// <param name="LsTrk"></param> /// <param name="Mtx"></param> /// <param name="rhs"></param> static public void SetPressureReferencePoint <T>(UnsetteledCoordinateMapping map, int iVar, LevelSetTracker LsTrk, BlockMsrMatrix Mtx, T rhs) where T : IList <double> { using (new FuncTrace()) { var GridDat = map.GridDat; if (rhs.Count != map.LocalLength) { throw new ArgumentException(); } if (!Mtx.RowPartitioning.EqualsPartition(map) || !Mtx.ColPartition.EqualsPartition(map)) { throw new ArgumentException(); } Basis PressureBasis = (Basis)map.BasisS[iVar]; int D = GridDat.SpatialDimension; long GlobalID, GlobalCellIndex; bool IsInside, onthisProc; GridDat.LocatePoint(new double[D], out GlobalID, out GlobalCellIndex, out IsInside, out onthisProc, LsTrk.Regions.GetCutCellSubGrid().VolumeMask.Complement()); int iRowGl = -111; if (onthisProc) { int jCell = (int)GlobalCellIndex - GridDat.CellPartitioning.i0; NodeSet CenterNode = new NodeSet(GridDat.iGeomCells.GetRefElement(jCell), new double[D]); MultidimensionalArray LevSetValues = LsTrk.DataHistories[0].Current.GetLevSetValues(CenterNode, jCell, 1);; MultidimensionalArray CenterNodeGlobal = MultidimensionalArray.Create(1, D); GridDat.TransformLocal2Global(CenterNode, CenterNodeGlobal, jCell); //Console.WriteLine("Pressure Ref Point @( {0:0.###E-00} | {1:0.###E-00} )", CenterNodeGlobal[0,0], CenterNodeGlobal[0,1]); LevelSetSignCode scode = LevelSetSignCode.ComputeLevelSetBytecode(LevSetValues[0, 0]); ReducedRegionCode rrc; int No = LsTrk.Regions.GetNoOfSpecies(jCell, out rrc); int iSpc = LsTrk.GetSpeciesIndex(rrc, scode); iRowGl = (int)map.GlobalUniqueCoordinateIndex_FromGlobal(iVar, GlobalCellIndex, 0); } iRowGl = iRowGl.MPIMax(); // clear row // --------- if (onthisProc) { // ref. cell is on local MPI process int jCell = (int)GlobalCellIndex - GridDat.CellPartitioning.i0; ReducedRegionCode rrc; int NoOfSpc = LsTrk.Regions.GetNoOfSpecies(jCell, out rrc); // set matrix row to identity Mtx.ClearRow(iRowGl); Mtx.SetDiagonalElement(iRowGl, 1.0); // clear RHS int iRow = iRowGl - Mtx.RowPartitioning.i0; rhs[iRow] = 0; } // clear column // ------------ { for (int i = Mtx.RowPartitioning.i0; i < Mtx.RowPartitioning.iE; i++) { if (i != iRowGl) { Mtx[i, iRowGl] = 0; } } } } }
static bool cmpRtfQueryO(Operator.Op op, object val1, object val2) { double n1 = NumberFunctions.Number(Rtf(val1)); NodeSet n2 = new NodeSet(val2); while (n2.MoveNext()) { if (cmpNumberNumberO(op, n1, NumberFunctions.Number(n2.Value))) { return true; } } return false; }