public virtual int func(BinaryTree.Node current, System.IComparable value) { if (value == null) { throw new System.ArgumentException(); } if (current == null) { return(0); } int x; if (value.CompareTo(current.value) < 0) { x = 1; } else { x = 0; } return(x + func(current.left, value) + func(current.right, value)); }
private int countLessThan(BinaryTree.Node current, System.IComparable value) { if (current == null) { return(0); } if (current.value == null) { return(0); } if (value == null) { return(0); } int count = 0; if (current.value.CompareTo(value) > 0) { return(1 + countLessThan(current.left, value) + countLessThan(current.right, value )); } return(countLessThan(current.left, value) + countLessThan(current.right, value)); }
private void CheckIfCanMergeWith(NeoDatis.Btree.IBTreeNode node) { if (nbKeys + node.GetNbKeys() > maxNbKeys) { throw new NeoDatis.Btree.Exception.BTreeException("Trying to merge two nodes with too many keys " + nbKeys + " + " + node.GetNbKeys() + " > " + maxNbKeys); } if (nbKeys > 0) { System.IComparable greatestOfThis = keys[nbKeys - 1]; System.IComparable smallestOfOther = node.GetKeyAt(0); if (greatestOfThis.CompareTo(smallestOfOther) >= 0) { throw new NeoDatis.Btree.Exception.BTreeNodeValidationException("Trying to merge two nodes that have intersections : " + ToString() + " / " + node); } } if (nbKeys < nbChildren) { throw new NeoDatis.Btree.Exception.BTreeNodeValidationException("Trying to merge two nodes where the first one has more children than keys" ); } }
protected internal virtual int countLessThan(System.IComparable value, BinaryTree.Node current) { if (current == null) { return(0); } int count = 0; if (value.CompareTo(current.value) < 0) { count++; } if (current.left != null) { count += countLessThan(value, current.left); } if (current.right != null) { count += countLessThan(value, current.right); } return(count); }
protected internal virtual int countLessThan(BinaryTree.Node current, System.IComparable value) { if (current == null) { return(0); } int num = 0; if (value.CompareTo(current.value) < 0) { num++; } if (current.right != null) { num = num + countLessThan(current.right, value); } if (current.left != null) { num = num + countLessThan(current.left, value); } return(num); }
private void add(BinaryTree.Node current, System.IComparable value) { if (current == null) { root = new BinaryTree.Node(this, value); } else if (current.right == null) { current.right = new BinaryTree.Node(this, value); } else if (current.left == null) { current.left = new BinaryTree.Node(this, value); } else if (random.Next(2) == 0) { add(current.right, value); } else { add(current.left, value); } }
private int countLessThan(BinaryTree.Node current, System.IComparable value) { if (current == null) { return(0); } int mySum = 0; int leftSum = 0; int rightSum = 0; if (current.value.CompareTo(value) > 0) { mySum = 1; } if (current.right != null) { rightSum = countLessThan(current.right, value); } if (current.left != null) { leftSum = countLessThan(current.left, value); } return(mySum + leftSum + rightSum); }
public static T UnsignedToSigned <T>(object value) where T : System.IComparable { if (value == null) { throw new System.ArgumentNullException(nameof(value), "Parameter cannot be NULL."); } System.Type t = value.GetType(); System.Type tRet = typeof(T); int sizeRet = System.Runtime.InteropServices.Marshal.SizeOf(tRet); int sizeValue = System.Runtime.InteropServices.Marshal.SizeOf(t); if (sizeRet != sizeValue) { throw new System.NotSupportedException($"Type mismatch: {tRet.Name} is not the matching signed type for {t.Name}"); } System.IComparable minValue = (System.IComparable)GetMinValue(t); System.IComparable minValueRet = (System.IComparable)GetMinValue(tRet); if (minValueRet.CompareTo(System.Convert.ChangeType(0, tRet)) == 0) { throw new System.NotSupportedException($"Type mismatch: {tRet.Name} is not a signed type."); } // If we already have an signed type // Type mismatch already prevented if (minValue.CompareTo(System.Convert.ChangeType(0, t)) != 0) { return((T)value); } return((T)UnsignedToSigned(value, t)); }
private int countLessThan(BinaryTree.Node current, System.IComparable value) { int count = 0; if (value == null) { throw new System.ArgumentException(); } if (current == null) { return(0); } if (current.left == null && current.right == null && current.value.CompareTo(value ) > 0) { return(1); } if (current.value.CompareTo(value) > 0) { count = 1; } return(count + countLessThan(current.left, value) + countLessThan(current.right, value)); }
public virtual void Insert(System.IComparable key, object value) { // check if root is full if (root.IsFull()) { NeoDatis.Btree.IBTreeNode newRoot = BuildNode(); NeoDatis.Btree.IBTreeNode oldRoot = root; newRoot.SetChildAt(root, 0); newRoot.SetNbChildren(1); root = newRoot; Split(newRoot, oldRoot, 0); height++; persister.SaveNode(oldRoot); // TODO Remove the save of the new root : the save on the btree // should do the save on the new root(after introspector // refactoring) persister.SaveNode(newRoot); persister.SaveBTree(this); NeoDatis.Btree.Tool.BTreeValidator.ValidateNode(newRoot, true); } InsertNonFull(root, key, value); size++; persister.SaveBTree(this); }
/** * Internal quicksort method that makes recursive calls. * Uses median-of-three partitioning and a cutoff of 10. * @param a an array of System.IComparable items. * @param left the left-most index of the subarray. * @param right the right-most index of the subarray. */ private static void quicksort(System.IComparable [] a, int left, int right) { /* 1*/ if (left + CUTOFF <= right) { /* 2*/ System.IComparable pivot = median3(a, left, right); // Begin partitioning /* 3*/ int i = left, j = right - 1; /* 4*/ for ( ; ;) { /* 5*/ while (a[++i].CompareTo(pivot) < 0) { } /* 6*/ while (a[--j].CompareTo(pivot) > 0) { } /* 7*/ if (i < j) { /* 8*/ swapReferences(a, i, j); } else { /* 9*/ break; } } /*10*/ swapReferences(a, i, right - 1); // Restore pivot /*11*/ quicksort(a, left, i - 1); // Sort small elements /*12*/ quicksort(a, i + 1, right); // Sort large elements } else // Do an insertion sort on the subarray /*13*/ { insertionSort(a, left, right); } }
public KeyAndValue(System.IComparable key, object value) { this.key = key; this.value = value; }
public virtual void SetKey(System.IComparable key) { this.key = key; }
internal Node(BinaryTree _enclosing, System.IComparable setValue) { this._enclosing = _enclosing; this.value = setValue; }
public virtual object Search(System.IComparable key) { NeoDatis.Btree.IBTreeNodeOneValuePerKey theRoot = (NeoDatis.Btree.IBTreeNodeOneValuePerKey )GetRoot(); return(theRoot.Search(key)); }
protected internal override int countLessThan(System.IComparable value) { return(countLessThan(value, root)); }
private static void CreateNumberControl(DisplayNameAttribute control, PropertyInfo prop, Vector2 anchorPosition) { UIRangeAttribute rangeAttr = prop.GetCustomAttribute <UIRangeAttribute>(); bool sliderControl = rangeAttr != null && rangeAttr.Slider; RectTransform element = Object.Instantiate(sliderControl ? sliderTemplate : inputTemplate, multiplayerContent, false); SetupUIElement(element, control, prop, anchorPosition); bool isFloatingPoint = prop.PropertyType == typeof(float) || prop.PropertyType == typeof(double); if (sliderControl) { Slider slider = element.GetComponentInChildren <Slider>(); slider.minValue = rangeAttr.Min; slider.maxValue = rangeAttr.Max; slider.wholeNumbers = !isFloatingPoint; Text sliderThumbText = slider.GetComponentInChildren <Text>(); slider.onValueChanged.RemoveAllListeners(); slider.onValueChanged.AddListener((value) => { prop.SetValue(tempMultiplayerOptions, value, null); sliderThumbText.text = value.ToString("0"); }); tempToUICallbacks[prop.Name] = () => { slider.value = (float)prop.GetValue(tempMultiplayerOptions, null); sliderThumbText.text = slider.value.ToString("0"); }; } else { InputField input = element.GetComponentInChildren <InputField>(); input.onValueChanged.RemoveAllListeners(); input.onValueChanged.AddListener((str) => { try { var converter = TypeDescriptor.GetConverter(prop.PropertyType); System.IComparable value = (System.IComparable)converter.ConvertFromString(str); if (rangeAttr != null) { System.IComparable min = (System.IComparable)System.Convert.ChangeType(rangeAttr.Min, prop.PropertyType); System.IComparable max = (System.IComparable)System.Convert.ChangeType(rangeAttr.Max, prop.PropertyType); if (value.CompareTo(min) < 0) { value = min; } if (value.CompareTo(max) > 0) { value = max; } input.text = value.ToString(); } prop.SetValue(tempMultiplayerOptions, value, null); } catch { // If the char is not a number, rollback to previous value input.text = prop.GetValue(tempMultiplayerOptions, null).ToString(); } }); tempToUICallbacks[prop.Name] = () => { input.text = prop.GetValue(tempMultiplayerOptions, null).ToString(); }; } }
public void add(System.IComparable value) { add(root, value); }
public virtual void SetKeyAndValueAt(System.IComparable key, object value, int index ) { keys[index] = key; values[index] = value; }
public SimpleCompareKey(System.IComparable key) { this.key = key; }
/// <summary>Returns the value of the deleted key</summary> /// <param name="node"></param> /// <param name="keyAndValue"></param> /// <returns></returns> /// <exception cref="System.Exception">System.Exception</exception> protected virtual object InternalDelete(NeoDatis.Btree.IBTreeNode node, NeoDatis.Btree.IKeyAndValue keyAndValue) { int position = node.GetPositionOfKey(keyAndValue.GetKey()); bool keyIsHere = position > 0; int realPosition = -1; NeoDatis.Btree.IBTreeNode leftNode = null; NeoDatis.Btree.IBTreeNode rightNode = null; try { if (node.IsLeaf()) { if (keyIsHere) { object deletedValue = node.DeleteKeyForLeafNode(keyAndValue); GetPersister().SaveNode(node); return(deletedValue); } // key does not exist return(null); } if (!keyIsHere) { // descend realPosition = -position - 1; NeoDatis.Btree.IBTreeNode child = node.GetChildAt(realPosition, true); if (child.GetNbKeys() == degree - 1) { node = PrepareForDelete(node, child, realPosition); return(InternalDelete(node, keyAndValue)); } return(InternalDelete(child, keyAndValue)); } // Here,the node is not a leaf and contains the key realPosition = position - 1; System.IComparable currentKey = node.GetKeyAt(realPosition); object currentValue = node.GetValueAsObjectAt(realPosition); // case 2a leftNode = node.GetChildAt(realPosition, true); if (leftNode.GetNbKeys() >= degree) { NeoDatis.Btree.IKeyAndValue prev = GetBiggest(leftNode, true); node.SetKeyAndValueAt(prev, realPosition); NeoDatis.Btree.Tool.BTreeValidator.ValidateNode(node, node == root); GetPersister().SaveNode(node); return(currentValue); } // case 2b rightNode = node.GetChildAt(realPosition + 1, true); if (rightNode.GetNbKeys() >= degree) { NeoDatis.Btree.IKeyAndValue next = GetSmallest(rightNode, true); node.SetKeyAndValueAt(next, realPosition); NeoDatis.Btree.Tool.BTreeValidator.ValidateNode(node, node == root); GetPersister().SaveNode(node); return(currentValue); } // case 2c // Here, both left and right part have degree-1 keys // remove the element to be deleted from node (shifting left all // right // elements, link to right link does not exist anymore) // insert the key to be deleted in left child and merge the 2 nodes. // rightNode should be deleted // if node is root, then leftNode becomes the new root and node // should be deleted // node.DeleteKeyAndValueAt(realPosition, true); leftNode.InsertKeyAndValue(currentKey, currentValue); leftNode.MergeWith(rightNode); // If node is the root and is empty if (!node.HasParent() && node.GetNbKeys() == 0) { persister.DeleteNode(node); root = leftNode; leftNode.SetParent(null); // The height has been decreased. No need to save btree here. // The calling delete method will save it. height--; } else { node.SetChildAt(leftNode, realPosition); // Node must only be validated if it is not the root NeoDatis.Btree.Tool.BTreeValidator.ValidateNode(node, node == root); } persister.DeleteNode(rightNode); NeoDatis.Btree.Tool.BTreeValidator.ValidateNode(leftNode, leftNode == root); GetPersister().SaveNode(node); GetPersister().SaveNode(leftNode); return(InternalDelete(leftNode, keyAndValue)); } finally { } }
/// <summary>LESS OR EQUAL</summary> /// <param name="attributeName">The attribute name</param> /// <param name="value">The value</param> /// <returns>The criterion</returns> public static NeoDatis.Odb.Core.Query.Criteria.ICriterion Le(string attributeName , System.IComparable value) { return(new NeoDatis.Odb.Core.Query.Criteria.ComparisonCriterion(attributeName, value , NeoDatis.Odb.Core.Query.Criteria.ComparisonCriterion.ComparisonTypeLe)); }
public virtual System.Collections.IList Search(System.IComparable key) { NeoDatis.Btree.IBTreeNodeMultipleValuesPerKey theRoot = (NeoDatis.Btree.IBTreeNodeMultipleValuesPerKey )GetRoot(); return(theRoot.Search(key)); }
public abstract void InsertKeyAndValue(System.IComparable key, object value);
protected internal virtual int countLessThan(System.IComparable value) { return(0); }
/// <summary>A geenric compare method</summary> /// <param name="c1"></param> /// <param name="c2"></param> /// <returns></returns> public static int Compare(System.IComparable c1, System.IComparable c2) { return(c1.CompareTo(c2)); }
public static int compare(object v1, object v2) { if (v1 == v2) { return(0); } if (v1 == null) { return(-1); } if (v2 == null) { return(1); } System.IConvertible cv1 = v1 as System.IConvertible; if (cv1 != null) { System.IConvertible cv2 = v2 as System.IConvertible; if (cv2 == null) { throw new System.ArgumentException("Cannot compare " + v1.GetType().ToString() + " and " + v2.GetType().ToString()); } switch (cv1.GetTypeCode()) { case System.TypeCode.String: if (cv2.GetTypeCode() != System.TypeCode.String) { throw new System.ArgumentException("Cannot compare " + v1.GetType().ToString() + " and " + v2.GetType().ToString()); } string s1 = v1 as string; string s2 = v2 as string; int i = 0; int l1 = s1.Length; int l2 = s2.Length; bool active = true; while (active) { char h1; char h2; if (i >= l1) { h1 = (char)0; active = false; } else { h1 = s1[i]; } if (i >= l2) { h2 = (char)0; active = false; } else { h2 = s2[i]; } int v = h1 - h2; if (v > 0) { return(1); } else if (v < 0) { return(-1); } i++; } return(0); case System.TypeCode.Double: double d1 = (double)v1; double d2 = cv2.ToDouble(null); return((d1 < d2) ? -1 : (d1 > d2) ? 1 : 0); default: double d1d = cv1.ToDouble(null); double d2d = cv2.ToDouble(null); return((d1d < d2d) ? -1 : (d1d > d2d) ? 1 : 0); } } System.IComparable c1 = v1 as System.IComparable; System.IComparable c2 = v2 as System.IComparable; if (c1 == null || c2 == null) { if (c1 == c2) { return(0); } throw new System.ArgumentException("Cannot compare " + v1.GetType().ToString() + " and " + v2.GetType().ToString()); } return(c1.CompareTo(c2)); }
public binTree(System.IComparable val) : base(val, null, true) { //which=true は、このノードが要素を持っている事を示す。 //ToDo:コンストラクションロジックは未だ書きおわっていない。 }
public Pair(System.IComparable key, object val) { Key = key; Val = val; }
public static int BinarySearch <T>(this System.Span <T> span, System.IComparable <T> comparable) { throw null; }
/** * Mergesort algorithm. * @param a an array of System.IComparable items. */ public static void mergeSort(System.IComparable [] a) { System.IComparable [] tmpArray = new System.IComparable[a.Length]; mergeSort(a, tmpArray, 0, a.Length - 1); }