appveyor test (#1)

Author: hanabi1224

.gitignore

@@ -0,0 +1,42 @@
+
+# Created by https://www.toptal.com/developers/gitignore/api/vscode,osx
+# Edit at https://www.toptal.com/developers/gitignore?templates=vscode,osx
+
+### OSX ###
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+### vscode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+*.code-workspace
+
+# End of https://www.toptal.com/developers/gitignore/api/vscode,osx

appveyor.yml

@@ -0,0 +1,33 @@
+version: 1.0.{build}
+image: Ubuntu2004
+pull_requests:
+    do_not_increment_build_number: true
+branches:
+    only:
+        - main
+build: off
+cache:
+    - /var/lib/docker
+    - /home/appveyor/.cache/yarn/v6
+    - /home/appveyor/.nuget/packages
+install:
+    - nvm use 14
+    - pushd website
+    - yarn
+    - popd
+build_script:
+    - pushd bench
+    - sudo dotnet run -c Release -p tool -- --task build --force-pull-docker true
+    - sudo dotnet run -c Release -p tool -- --task test
+    - sudo dotnet run -c Release -p tool -- --task bench
+    - popd
+    - pushd website
+    - yarn
+    - yarn content
+    - yarn generate
+    - popd
+artifacts:
+    - path: bench/build
+      name: benchmark
+    - path: website/dist
+      name: website

bench/.gitignore

@@ -0,0 +1,2 @@
+build
+.tmp

bench/algorithm/binarytrees/1.go

@@ -0,0 +1,67 @@
+/* The Computer Language Benchmarks Game
+ * https://salsa.debian.org/benchmarksgame-team/benchmarksgame/
+ *
+ * contributed by The Go Authors.
+ * based on C program by Kevin Carson
+ * flag.Arg hack by Isaac Gouy
+ * *reset*
+ */
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"strconv"
+)
+
+var n = 0
+
+type Node struct {
+	left, right *Node
+}
+
+func bottomUpTree(depth int) *Node {
+	if depth <= 0 {
+		return &Node{}
+	}
+	return &Node{bottomUpTree(depth - 1), bottomUpTree(depth - 1)}
+}
+
+func (n *Node) itemCheck() int {
+	if n.left == nil {
+		return 1
+	}
+	return 1 + n.left.itemCheck() + n.right.itemCheck()
+}
+
+const minDepth = 4
+
+func main() {
+	flag.Parse()
+	if flag.NArg() > 0 {
+		n, _ = strconv.Atoi(flag.Arg(0))
+	}
+
+	maxDepth := n
+	if minDepth+2 > n {
+		maxDepth = minDepth + 2
+	}
+	stretchDepth := maxDepth + 1
+
+	check := bottomUpTree(stretchDepth).itemCheck()
+	fmt.Printf("stretch tree of depth %d\t check: %d\n", stretchDepth, check)
+
+	longLivedTree := bottomUpTree(maxDepth)
+
+	for depth := minDepth; depth <= maxDepth; depth += 2 {
+		iterations := 1 << uint(maxDepth-depth+minDepth)
+		check = 0
+
+		for i := 1; i <= iterations; i++ {
+			check += bottomUpTree(depth).itemCheck()
+		}
+		fmt.Printf("%d\t trees of depth %d\t check: %d\n", iterations, depth, check)
+	}
+	fmt.Printf("long lived tree of depth %d\t check: %d\n", maxDepth, longLivedTree.itemCheck())
+}

bench/algorithm/binarytrees/10_out

@@ -0,0 +1,6 @@
+stretch tree of depth 11	 check: 4095
+1024	 trees of depth 4	 check: 31744
+256	 trees of depth 6	 check: 32512
+64	 trees of depth 8	 check: 32704
+16	 trees of depth 10	 check: 32752
+long lived tree of depth 10	 check: 2047

bench/algorithm/binarytrees/2.go

@@ -0,0 +1,97 @@
+/* The Computer Language Benchmarks Game
+ * https://salsa.debian.org/benchmarksgame-team/benchmarksgame/
+ *
+ * Contributed by Alexandr Karbivnichiy
+ */
+
+package main
+
+import (
+	"flag"
+	"fmt"
+	"sort"
+	"strconv"
+	"sync"
+)
+
+type Node struct {
+	next *Next
+}
+
+type Next struct {
+	left, right Node
+}
+
+func createTree(depth int) Node {
+	if depth > 1 {
+		return Node{&Next{createTree(depth - 1), createTree(depth - 1)}}
+	}
+	return Node{&Next{Node{}, Node{}}}
+}
+
+func checkTree(node Node) int {
+	sum := 1
+	current := node.next
+	for current != nil {
+		sum += checkTree(current.right) + 1
+		current = current.left.next
+	}
+	return sum
+}
+
+func main() {
+	n := 0
+	flag.Parse()
+	if flag.NArg() > 0 {
+		n, _ = strconv.Atoi(flag.Arg(0))
+	}
+	run(n)
+}
+
+func run(maxDepth int) {
+	const minDepth = 4
+	var longLivedTree Node
+	var group sync.WaitGroup
+	var messages sync.Map
+
+	if minDepth+2 > maxDepth {
+		maxDepth = minDepth + 2
+	}
+
+	group.Add(1)
+	go func() {
+		messages.Store(-1, fmt.Sprintf("stretch tree of depth %d\t check: %d",
+			maxDepth+1, checkTree(createTree(maxDepth+1))))
+		longLivedTree = createTree(maxDepth)
+		group.Done()
+	}()
+
+	for halfDepth := minDepth / 2; halfDepth < maxDepth/2+1; halfDepth++ {
+		iters := 1 << (maxDepth - (halfDepth * 2) + minDepth)
+		group.Add(1)
+		go func(depth, iters, chk int) {
+			for i := 0; i < iters; i++ {
+				chk += checkTree(createTree(depth))
+			}
+			messages.Store(depth, fmt.Sprintf("%d\t trees of depth %d\t check: %d",
+				iters, depth, chk))
+			group.Done()
+		}(halfDepth*2, iters, 0)
+	}
+
+	group.Wait()
+
+	var idxs []int
+	messages.Range(func(key, val interface{}) bool {
+		idxs = append(idxs, key.(int))
+		return true
+	})
+	sort.Ints(idxs)
+	for _, idx := range idxs {
+		msg, _ := messages.Load(idx)
+		fmt.Println(msg)
+	}
+
+	fmt.Printf("long lived tree of depth %d\t check: %d\n",
+		maxDepth, checkTree(longLivedTree))
+}

bench/algorithm/binarytrees/2.java

@@ -0,0 +1,64 @@
+/* The Computer Language Benchmarks Game
+   https://salsa.debian.org/benchmarksgame-team/benchmarksgame/
+ 
+   contributed by Jarkko Miettinen
+   *reset*
+*/
+
+class binarytrees {
+
+   private final static int minDepth = 4;
+   
+   public static void main(String[] args){
+      int n = 0;
+      if (args.length > 0) n = Integer.parseInt(args[0]);
+      
+      int maxDepth = (minDepth + 2 > n) ? minDepth + 2 : n;
+      int stretchDepth = maxDepth + 1;
+      
+      int check = (TreeNode.bottomUpTree(stretchDepth)).itemCheck();
+      System.out.println("stretch tree of depth "+stretchDepth+"\t check: " + check);
+      
+      TreeNode longLivedTree = TreeNode.bottomUpTree(maxDepth);
+      
+      for (int depth=minDepth; depth<=maxDepth; depth+=2){
+         int iterations = 1 << (maxDepth - depth + minDepth);
+         check = 0;
+         
+         for (int i=1; i<=iterations; i++){
+            check += (TreeNode.bottomUpTree(depth)).itemCheck();
+         }
+         System.out.println(iterations + "\t trees of depth " + depth + "\t check: " + check);
+      }   
+      System.out.println("long lived tree of depth " + maxDepth + "\t check: "+ longLivedTree.itemCheck());
+   }
+   
+   
+   private static class TreeNode
+   {
+      private TreeNode left, right;
+      
+      private static TreeNode bottomUpTree(int depth){
+         if (depth>0){
+            return new TreeNode(
+                  bottomUpTree(depth-1)
+                  , bottomUpTree(depth-1)
+            );
+         }
+         else {
+            return new TreeNode(null,null);
+         }
+      }
+      
+      TreeNode(TreeNode left, TreeNode right){
+         this.left = left;
+         this.right = right;
+      }
+      
+      private int itemCheck(){
+         // if necessary deallocate here
+         if (left==null) return 1;
+         else return 1 + left.itemCheck() + right.itemCheck();
+      }
+   }
+}

bench/algorithm/binarytrees/3.cs

@@ -0,0 +1,75 @@
+namespace BenchmarkGameBTrees
+{
+    /*
+          The Computer Language Benchmarks Game
+          https://salsa.debian.org/benchmarksgame-team/benchmarksgame/ 
+
+          contributed by Marek Safar  
+          optimized by kasthack
+          *reset*
+    */
+    using System;
+    using System.Threading;
+    using System.Threading.Tasks;
+
+    class BinaryTrees
+    {
+        const int minDepth = 4;
+        public static void Main(String[] args)
+        {
+            int n = 0;
+            if (args.Length > 0) n = Int32.Parse(args[0]);
+            int maxDepth = Math.Max(minDepth + 2, n);
+            int stretchDepth = maxDepth + 1;
+            int check = (TreeNode.bottomUpTree(stretchDepth)).itemCheck();
+            Console.WriteLine("stretch tree of depth {0}\t check: {1}", stretchDepth, check);
+            TreeNode longLivedTree = TreeNode.bottomUpTree(maxDepth);
+            for (int depth = minDepth; depth <= maxDepth; depth += 2)
+            {
+                int iterations = 1 << (maxDepth - depth + minDepth);
+                check = 0;
+
+                Parallel.For(1, iterations + 1,
+                    () => 0,
+                    (i, loop, localCheck) =>
+                    {
+                        return localCheck + 
+                            (TreeNode.bottomUpTree(depth)).itemCheck();
+                    },
+                    localCheck => Interlocked.Add(ref check, localCheck)
+                );
+
+                Console.WriteLine("{0}\t trees of depth {1}\t check: {2}",
+                    iterations, depth, check);
+            }
+            Console.WriteLine("long lived tree of depth {0}\t check: {1}",
+                maxDepth, longLivedTree.itemCheck());
+        }
+
+        class TreeNode
+        {
+            private TreeNode left, right;
+
+            internal static TreeNode bottomUpTree(int depth)
+            {
+                TreeNode t;
+                ChildTreeNodes(out t, depth);
+                return t;
+            }
+            static void ChildTreeNodes(out TreeNode node, int depth)
+            {
+                node = new TreeNode();
+                if (depth > 0)
+                {
+                    ChildTreeNodes(out node.left, depth - 1);
+                    ChildTreeNodes(out node.right, depth - 1);
+                }
+            }
+            internal int itemCheck()
+            {
+                if (right == null) return 1;
+                else return 1 + left.itemCheck() + right.itemCheck();
+            }
+        }
+    }
+}