all tasks

Task/Variable-size-Set/0DESCRIPTION

@@ -0,0 +1 @@
+Demonstrate how to specify the minimum size of a variable or a data type.

Task/Variable-size-Set/1META.yaml

@@ -0,0 +1,2 @@
+---
+note: Type System

Task/Variable-size-Set/Ada/variable-size-set.ada

@@ -0,0 +1,2 @@
+type Response is (Yes, No); -- Definition of an enumeration type with two values
+for Response'Size use 1; -- Setting the size of Response to 1 bit, rather than the default single byte size

Task/Variable-size-Set/BASIC/variable-size-set.basic

@@ -0,0 +1,3 @@
+10 DIM A%(10): REM the array size is 10 integers
+20 DIM B(10): REM the array will hold 10 floating point values
+30 DIM C$(12): REM a character array of 12 bytes

Task/Variable-size-Set/BBC-BASIC/variable-size-set.bbc

@@ -0,0 +1,4 @@
+      var& = 1 : REM Variable occupies 8 bits
+      var% = 1 : REM Variable occupies 32 bits
+      var  = 1 : REM Variable occupies 40 bits
+      var# = 1 : REM Variable occupies 64 bits

Task/Variable-size-Set/C++/variable-size-set.cpp

@@ -0,0 +1,3 @@
+#include <boost/cstdint.hpp>
+
+boost::int_least32_t foo;

Task/Variable-size-Set/C/variable-size-set.c

@@ -0,0 +1,3 @@
+#include <stdint.h>
+
+int_least32_t foo;

Task/Variable-size-Set/D/variable-size-set-1.d

@@ -0,0 +1,2 @@
+typedef long[0] zeroLength ;
+writefln(zeroLength.sizeof) ; // print 0

Task/Variable-size-Set/D/variable-size-set-2.d

@@ -0,0 +1,4 @@
+byte b ;
+ubyte ub ;
+char c ;
+bool t ;

Task/Variable-size-Set/D/variable-size-set-3.d

@@ -0,0 +1,2 @@
+struct Empty { }
+writefln(Empty.sizeof) ; // print 1

Task/Variable-size-Set/Fortran/variable-size-set.f

@@ -0,0 +1,43 @@
+program setsize
+implicit none
+
+  integer, parameter :: p1 = 6
+  integer, parameter :: p2 = 12
+  integer, parameter :: r1 = 30
+  integer, parameter :: r2 = 1000
+  integer, parameter :: r3 = 2
+  integer, parameter :: r4 = 4
+  integer, parameter :: r5 = 8
+  integer, parameter :: r6 = 16
+  integer, parameter :: rprec1 = selected_real_kind(p1, r1)
+  integer, parameter :: rprec2 = selected_real_kind(p2, r1)
+  integer, parameter :: rprec3 = selected_real_kind(p2, r2)
+  integer, parameter :: iprec1 = selected_int_kind(r3)
+  integer, parameter :: iprec2 = selected_int_kind(r4)
+  integer, parameter :: iprec3 = selected_int_kind(r5)
+  integer, parameter :: iprec4 = selected_int_kind(r6)
+
+  real(rprec1)    :: n1
+  real(rprec2)    :: n2
+  real(rprec3)    :: n3
+  integer(iprec1) :: n4
+  integer(iprec2) :: n5
+  integer(iprec3) :: n6
+  integer(iprec4) :: n7
+  character(30) :: form
+
+  form = "(a7, i11, i10, i6, i9, i8)"
+  write(*, "(a)") "KIND NAME   KIND NUMBER   PRECISION        RANGE "
+  write(*, "(a)") "                          min   set     min     set"
+  write(*, "(a)") "______________________________________________________"
+  write(*, form) "rprec1", kind(n1), p1, precision(n1), r1, range(n1)
+  write(*, form) "rprec2", kind(n2), p2, precision(n2), r1, range(n2)
+  write(*, form) "rprec3", kind(n3), p2, precision(n3), r2, range(n3)
+  write(*,*)
+  form = "(a7, i11, i25, i8)"
+  write(*, form) "iprec1", kind(n4), r3, range(n4)
+  write(*, form) "iprec2", kind(n5), r4, range(n5)
+  write(*, form) "iprec3", kind(n6), r5, range(n6)
+  write(*, form) "iprec4", kind(n7), r6, range(n7)
+
+end program

Task/Variable-size-Set/Go/variable-size-set.go

@@ -0,0 +1,25 @@
+package main
+
+import (
+    "fmt"
+    "unsafe"
+)
+
+func main() {
+    i := 5   // default type is int
+    r := '5' // default type is rune (which is int32)
+    f := 5.  // default type is float64
+    c := 5i  // default type is complex128
+    fmt.Println("i:", unsafe.Sizeof(i), "bytes")
+    fmt.Println("r:", unsafe.Sizeof(r), "bytes")
+    fmt.Println("f:", unsafe.Sizeof(f), "bytes")
+    fmt.Println("c:", unsafe.Sizeof(c), "bytes")
+    iMin := int8(5)
+    rMin := byte('5')
+    fMin := float32(5.)
+    cMin := complex64(5i)
+    fmt.Println("iMin:", unsafe.Sizeof(iMin), "bytes")
+    fmt.Println("rMin:", unsafe.Sizeof(rMin), "bytes")
+    fmt.Println("fMin:", unsafe.Sizeof(fMin), "bytes")
+    fmt.Println("cMin:", unsafe.Sizeof(cMin), "bytes")
+}

Task/Variable-size-Set/Icon/variable-size-set.icon

@@ -0,0 +1 @@
+   L := list(10) # 10 element list

Task/Variable-size-Set/J/variable-size-set.j

@@ -0,0 +1 @@
+v=: ''

Task/Variable-size-Set/Modula-3/variable-size-set.mod3

@@ -0,0 +1 @@
+TYPE UByte = BITS 8 FOR [0..255];

Task/Variable-size-Set/PARI-GP/variable-size-set-1.pari

@@ -0,0 +1 @@
+default(precision, 1000)

Task/Variable-size-Set/PARI-GP/variable-size-set-2.pari

@@ -0,0 +1 @@
+\p 1000

Task/Variable-size-Set/PL-I/variable-size-set.pli

@@ -0,0 +1,16 @@
+declare i fixed binary (7),  /* occupies one byte  */
+        j fixed binary (15), /* occupies two bytes */
+        k fixed binary (31), /* occupies 4 bytes   */
+        l fixed binary (63); /* occupies 8 bytes   */
+
+declare d fixed decimal (1), /* occupies 1 byte    */
+        e fixed decimal (3), /* occupies 2 bytes   */
+                             /* an so on ...       */
+        f fixed decimal (15); /* occupies 8 bytes. */
+
+declare b(16) bit (1) unaligned; /* occupies 2 bytes  */
+declare c(16) bit (1) aligned;   /* occupies 16 bytes */
+
+declare x float,              /* occupies 4 bytes. */
+        y float (15),         /* occupies 8 bytes. */
+        z float (18);         /* occupies 10 bytes */

Task/Variable-size-Set/Pascal/variable-size-set.pascal

@@ -0,0 +1,8 @@
+var
+  a: byte;     // 1 byte
+  b: word;     // 2 byte
+  c: cardinal; // 4 byte
+  d: QWord;    // 8 byte
+
+  x: real;   // 4 byte
+  y: double; // 8 byte

Task/Variable-size-Set/REXX/variable-size-set.rexx

@@ -0,0 +1,2 @@
+numeric digits 100
+abc=12345678901111111112222222222333333333344444444445555555555.66

Task/Variable-size-Set/Tcl/variable-size-set-1.tcl

@@ -0,0 +1,9 @@
+% proc format_trace {fmt _var el op} {upvar 1 $_var v; set v [format $fmt $v]}
+
+% trace var foo w {format_trace %10s}
+% puts "/[set foo bar]/"
+/       bar/
+
+% trace var grill w {format_trace %-10s}
+% puts "/[set grill bar]/"
+/bar       /

Task/Variable-size-Set/Tcl/variable-size-set-2.tcl

@@ -0,0 +1,5 @@
+% proc range_trace {n _var el op} {upvar 1 $_var v; set v [string range $v 0 [incr n -1]]}
+
+% trace var baz w {range_trace 2}
+% set baz Frankfurt
+Fr

Task/Variable-size-Set/Ursala/variable-size-set.ursala

@@ -0,0 +1,11 @@
+p = mpfr..pi 200               # 200 bits of precision
+
+x = mpfr..grow(1.0E+0,1000)    # 160 default precision, grown to 1160
+
+y = mpfr..shrink(1.0+0,40)     # 160 default shrunk to 120
+
+z = mpfr..add(p,y)             # inherits 200 bits of precision
+
+a = # 180 bits (not the default 160) because of more digits in the constant
+
+1.00000000000000000000000000000000000000000000000000000E0

Task/Variable-size-Set/XPL0/variable-size-set.xpl0

@@ -0,0 +1,13 @@
+include c:\cxpl\codes;  \intrinsic 'code' declarations
+string 0;               \use zero-terminated strings
+char S,
+     A(1),              \sets up an array containing one byte
+     B(0);              \sets up an array containing no bytes
+int  I;
+[S:= "";                \a zero-length (null) string
+A:= Reserve(1);         \sets up a 1-byte array at runtime
+B:= Reserve(0);         \sets up a 0-byte array at runtime
+I:= I ! 1<<3;           \stores a single 1 bit into an integer
+I:= I & ~(1<<29);       \stores a 0 bit into bit 29 of the integer
+IntOut(0, I>>3 & 1);    \displays value of bit 3
+]

Task/Variable-size-Set/ZX-Spectrum-Basic/variable-size-set.zx

@@ -0,0 +1,3 @@
+10 DIM a$(10): REM This array will be 10 characters long
+20 DIM b(10): REM this will hold a set of numbers. The fixed number of bytes per number is implementation specific
+30 LET c=5: REM this is a single numerical value of fixed size