mapFolding 0.3.12__py3-none-any.whl → 0.4.0__py3-none-any.whl

mapFolding/reference/total_countPlus1vsPlusN.py

@@ -3,209 +3,209 @@ import numpy
 
 @njit(cache=True)
 def foldings_plus_1(p: list[int], computationDivisions: int = 0, computationIndex: int = 0) -> int:
-    n: int = 1  # Total number of leaves
-    for dimension in p:
-        n *= dimension
-
-    d = len(p)  # Number of dimensions
-    # Compute arrays P, C, D as per the algorithm
-    P = numpy.ones(d + 1, dtype=numpy.int64)
-    for i in range(1, d + 1):
-        P[i] = P[i - 1] * p[i - 1]
-
-    # C[i][m] holds the i-th coordinate of leaf m
-    C = numpy.zeros((d + 1, n + 1), dtype=numpy.int64)
-    for i in range(1, d + 1):
-        for m in range(1, n + 1):
-            C[i][m] = ((m - 1) // P[i - 1]) - ((m - 1) // P[i]) * p[i - 1] + 1
-
-    # D[i][l][m] computes the leaf connected to m in section i when inserting l
-    D = numpy.zeros((d + 1, n + 1, n + 1), dtype=numpy.int64)
-    for i in range(1, d + 1):
-        for l in range(1, n + 1):
-            for m in range(1, l + 1):
-                delta = C[i][l] - C[i][m]
-                if delta % 2 == 0:
-                    # If delta is even
-                    if C[i][m] == 1:
-                        D[i][l][m] = m
-                    else:
-                        D[i][l][m] = m - P[i - 1]
-                else:
-                    # If delta is odd
-                    if C[i][m] == p[i - 1] or m + P[i - 1] > l:
-                        D[i][l][m] = m
-                    else:
-                        D[i][l][m] = m + P[i - 1]
-    # Initialize arrays/lists
-    A = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf above leaf m
-    B = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf below leaf m
-    count = numpy.zeros(n + 1, dtype=numpy.int64)   # Counts for potential gaps
-    gapter = numpy.zeros(n + 1, dtype=numpy.int64)  # Indices for gap stack per leaf
-    gap = numpy.zeros(n * n + 1, dtype=numpy.int64) # Stack of potential gaps
-
-
-    # Initialize variables for backtracking
-    total_count = 0  # Total number of foldings
-    g = 0            # Gap index
-    l = 1            # Current leaf
-
-    # Start backtracking loop
-    while l > 0:
-        # If we have processed all leaves, increment total count
-        if l > n:
-            total_count += 1
-        else:
-            dd = 0     # Number of sections where leaf l is unconstrained
-            gg = g     # Temporary gap index
-            g = gapter[l - 1]  # Reset gap index for current leaf
-
-            # Count possible gaps for leaf l in each section
-            for i in range(1, d + 1):
-                if D[i][l][l] == l:
-                    dd += 1
-                else:
-                    m = D[i][l][l]
-                    while m != l:
-                        if computationDivisions == 0 or l != computationDivisions or m % computationDivisions == computationIndex:
-                            gap[gg] = m
-                            if count[m] == 0:
-                                gg += 1
-                            count[m] += 1
-                        m = D[i][l][B[m]]
-
-            # If leaf l is unconstrained in all sections, it can be inserted anywhere
-            if dd == d:
-                for m in range(l):
-                    gap[gg] = m
-                    gg += 1
-
-            # Filter gaps that are common to all sections
-            for j in range(g, gg):
-                gap[g] = gap[j]
-                if count[gap[j]] == d - dd:
-                    g += 1
-                count[gap[j]] = 0  # Reset count for next iteration
-
-        # Recursive backtracking steps
-        while l > 0 and g == gapter[l - 1]:
-            l -= 1
-            B[A[l]] = B[l]
-            A[B[l]] = A[l]
-
-        if l > 0:
-            g -= 1
-            A[l] = gap[g]
-            B[l] = B[A[l]]
-            B[A[l]] = l
-            A[B[l]] = l
-            gapter[l] = g  # Save current gap index
-            l += 1         # Move to next leaf
-
-    return total_count
+	n: int = 1  # Total number of leaves
+	for dimension in p:
+		n *= dimension
+
+	d = len(p)  # Number of dimensions
+	# Compute arrays P, C, D as per the algorithm
+	P = numpy.ones(d + 1, dtype=numpy.int64)
+	for i in range(1, d + 1):
+		P[i] = P[i - 1] * p[i - 1]
+
+	# C[i][m] holds the i-th coordinate of leaf m
+	C = numpy.zeros((d + 1, n + 1), dtype=numpy.int64)
+	for i in range(1, d + 1):
+		for m in range(1, n + 1):
+			C[i][m] = ((m - 1) // P[i - 1]) - ((m - 1) // P[i]) * p[i - 1] + 1
+
+	# D[i][l][m] computes the leaf connected to m in section i when inserting l
+	D = numpy.zeros((d + 1, n + 1, n + 1), dtype=numpy.int64)
+	for i in range(1, d + 1):
+		for l in range(1, n + 1):
+			for m in range(1, l + 1):
+				delta = C[i][l] - C[i][m]
+				if delta % 2 == 0:
+					# If delta is even
+					if C[i][m] == 1:
+						D[i][l][m] = m
+					else:
+						D[i][l][m] = m - P[i - 1]
+				else:
+					# If delta is odd
+					if C[i][m] == p[i - 1] or m + P[i - 1] > l:
+						D[i][l][m] = m
+					else:
+						D[i][l][m] = m + P[i - 1]
+	# Initialize arrays/lists
+	A = numpy.zeros(n + 1, dtype=numpy.int64)	   # Leaf above leaf m
+	B = numpy.zeros(n + 1, dtype=numpy.int64)	   # Leaf below leaf m
+	count = numpy.zeros(n + 1, dtype=numpy.int64)   # Counts for potential gaps
+	gapter = numpy.zeros(n + 1, dtype=numpy.int64)  # Indices for gap stack per leaf
+	gap = numpy.zeros(n * n + 1, dtype=numpy.int64) # Stack of potential gaps
+
+
+	# Initialize variables for backtracking
+	total_count = 0  # Total number of foldings
+	g = 0			# Gap index
+	l = 1			# Current leaf
+
+	# Start backtracking loop
+	while l > 0:
+		# If we have processed all leaves, increment total count
+		if l > n:
+			total_count += 1
+		else:
+			dd = 0	 # Number of sections where leaf l is unconstrained
+			gg = g	 # Temporary gap index
+			g = gapter[l - 1]  # Reset gap index for current leaf
+
+			# Count possible gaps for leaf l in each section
+			for i in range(1, d + 1):
+				if D[i][l][l] == l:
+					dd += 1
+				else:
+					m = D[i][l][l]
+					while m != l:
+						if computationDivisions == 0 or l != computationDivisions or m % computationDivisions == computationIndex:
+							gap[gg] = m
+							if count[m] == 0:
+								gg += 1
+							count[m] += 1
+						m = D[i][l][B[m]]
+
+			# If leaf l is unconstrained in all sections, it can be inserted anywhere
+			if dd == d:
+				for m in range(l):
+					gap[gg] = m
+					gg += 1
+
+			# Filter gaps that are common to all sections
+			for j in range(g, gg):
+				gap[g] = gap[j]
+				if count[gap[j]] == d - dd:
+					g += 1
+				count[gap[j]] = 0  # Reset count for next iteration
+
+		# Recursive backtracking steps
+		while l > 0 and g == gapter[l - 1]:
+			l -= 1
+			B[A[l]] = B[l]
+			A[B[l]] = A[l]
+
+		if l > 0:
+			g -= 1
+			A[l] = gap[g]
+			B[l] = B[A[l]]
+			B[A[l]] = l
+			A[B[l]] = l
+			gapter[l] = g  # Save current gap index
+			l += 1		 # Move to next leaf
+
+	return total_count
 
 @njit(cache=True)
 def foldings(p: list[int], computationDivisions: int = 0, computationIndex: int = 0) -> int:
-    n: int = 1  # Total number of leaves
-    for dimension in p:
-        n *= dimension
-
-    d = len(p)  # Number of dimensions
-    # Compute arrays P, C, D as per the algorithm
-    P = numpy.ones(d + 1, dtype=numpy.int64)
-    for i in range(1, d + 1):
-        P[i] = P[i - 1] * p[i - 1]
-
-    # C[i][m] holds the i-th coordinate of leaf m
-    C = numpy.zeros((d + 1, n + 1), dtype=numpy.int64)
-    for i in range(1, d + 1):
-        for m in range(1, n + 1):
-            C[i][m] = ((m - 1) // P[i - 1]) - ((m - 1) // P[i]) * p[i - 1] + 1
-            # C[i][m] = ((m - 1) // P[i - 1]) % p[i - 1] + 1 # NOTE different, but either one works
-
-    # D[i][l][m] computes the leaf connected to m in section i when inserting l
-    D = numpy.zeros((d + 1, n + 1, n + 1), dtype=numpy.int64)
-    for i in range(1, d + 1):
-        for l in range(1, n + 1):
-            for m in range(1, l + 1):
-                delta = C[i][l] - C[i][m]
-                if delta % 2 == 0:
-                    # If delta is even
-                    if C[i][m] == 1:
-                        D[i][l][m] = m
-                    else:
-                        D[i][l][m] = m - P[i - 1]
-                else:
-                    # If delta is odd
-                    if C[i][m] == p[i - 1] or m + P[i - 1] > l:
-                        D[i][l][m] = m
-                    else:
-                        D[i][l][m] = m + P[i - 1]
-    # Initialize arrays/lists
-    A = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf above leaf m
-    B = numpy.zeros(n + 1, dtype=numpy.int64)       # Leaf below leaf m
-    count = numpy.zeros(n + 1, dtype=numpy.int64)   # Counts for potential gaps
-    gapter = numpy.zeros(n + 1, dtype=numpy.int64)  # Indices for gap stack per leaf
-    gap = numpy.zeros(n * n + 1, dtype=numpy.int64) # Stack of potential gaps
-
-
-    # Initialize variables for backtracking
-    total_count = 0  # Total number of foldings
-    g = 0            # Gap index
-    l = 1            # Current leaf
-
-    # Start backtracking loop
-    while l > 0:
-        if l <= 1 or B[0] == 1: # NOTE different
-            # NOTE the above `if` statement encloses the the if/else block below
-            # NOTE these changes increase the throughput by more than an order of magnitude
-            if l > n:
-                total_count += n
-            else:
-                dd = 0     # Number of sections where leaf l is unconstrained
-                gg = gapter[l - 1]  # Track possible gaps # NOTE different, but not important
-                g = gg # NOTE different, but not important
-
-                # Count possible gaps for leaf l in each section
-                for i in range(1, d + 1):
-                    if D[i][l][l] == l:
-                        dd += 1
-                    else:
-                        m = D[i][l][l]
-                        while m != l:
-                            if computationDivisions == 0 or l != computationDivisions or m % computationDivisions == computationIndex:
-                                gap[gg] = m
-                                if count[m] == 0:
-                                    gg += 1
-                                count[m] += 1
-                            m = D[i][l][B[m]]
-
-                # If leaf l is unconstrained in all sections, it can be inserted anywhere
-                if dd == d:
-                    for m in range(l):
-                        gap[gg] = m
-                        gg += 1
-
-                # Filter gaps that are common to all sections
-                for j in range(g, gg):
-                    gap[g] = gap[j]
-                    if count[gap[j]] == d - dd:
-                        g += 1
-                    count[gap[j]] = 0  # Reset count for next iteration
-
-        # Recursive backtracking steps
-        while l > 0 and g == gapter[l - 1]:
-            l -= 1
-            B[A[l]] = B[l]
-            A[B[l]] = A[l]
-
-        if l > 0:
-            g -= 1
-            A[l] = gap[g]
-            B[l] = B[A[l]]
-            B[A[l]] = l
-            A[B[l]] = l
-            gapter[l] = g  # Save current gap index
-            l += 1         # Move to next leaf
-
-    return total_count
+	n: int = 1  # Total number of leaves
+	for dimension in p:
+		n *= dimension
+
+	d = len(p)  # Number of dimensions
+	# Compute arrays P, C, D as per the algorithm
+	P = numpy.ones(d + 1, dtype=numpy.int64)
+	for i in range(1, d + 1):
+		P[i] = P[i - 1] * p[i - 1]
+
+	# C[i][m] holds the i-th coordinate of leaf m
+	C = numpy.zeros((d + 1, n + 1), dtype=numpy.int64)
+	for i in range(1, d + 1):
+		for m in range(1, n + 1):
+			C[i][m] = ((m - 1) // P[i - 1]) - ((m - 1) // P[i]) * p[i - 1] + 1
+			# C[i][m] = ((m - 1) // P[i - 1]) % p[i - 1] + 1 # NOTE different, but either one works
+
+	# D[i][l][m] computes the leaf connected to m in section i when inserting l
+	D = numpy.zeros((d + 1, n + 1, n + 1), dtype=numpy.int64)
+	for i in range(1, d + 1):
+		for l in range(1, n + 1):
+			for m in range(1, l + 1):
+				delta = C[i][l] - C[i][m]
+				if delta % 2 == 0:
+					# If delta is even
+					if C[i][m] == 1:
+						D[i][l][m] = m
+					else:
+						D[i][l][m] = m - P[i - 1]
+				else:
+					# If delta is odd
+					if C[i][m] == p[i - 1] or m + P[i - 1] > l:
+						D[i][l][m] = m
+					else:
+						D[i][l][m] = m + P[i - 1]
+	# Initialize arrays/lists
+	A = numpy.zeros(n + 1, dtype=numpy.int64)	   # Leaf above leaf m
+	B = numpy.zeros(n + 1, dtype=numpy.int64)	   # Leaf below leaf m
+	count = numpy.zeros(n + 1, dtype=numpy.int64)   # Counts for potential gaps
+	gapter = numpy.zeros(n + 1, dtype=numpy.int64)  # Indices for gap stack per leaf
+	gap = numpy.zeros(n * n + 1, dtype=numpy.int64) # Stack of potential gaps
+
+
+	# Initialize variables for backtracking
+	total_count = 0  # Total number of foldings
+	g = 0			# Gap index
+	l = 1			# Current leaf
+
+	# Start backtracking loop
+	while l > 0:
+		if l <= 1 or B[0] == 1: # NOTE different
+			# NOTE the above `if` statement encloses the the if/else block below
+			# NOTE these changes increase the throughput by more than an order of magnitude
+			if l > n:
+				total_count += n
+			else:
+				dd = 0	 # Number of sections where leaf l is unconstrained
+				gg = gapter[l - 1]  # Track possible gaps # NOTE different, but not important
+				g = gg # NOTE different, but not important
+
+				# Count possible gaps for leaf l in each section
+				for i in range(1, d + 1):
+					if D[i][l][l] == l:
+						dd += 1
+					else:
+						m = D[i][l][l]
+						while m != l:
+							if computationDivisions == 0 or l != computationDivisions or m % computationDivisions == computationIndex:
+								gap[gg] = m
+								if count[m] == 0:
+									gg += 1
+								count[m] += 1
+							m = D[i][l][B[m]]
+
+				# If leaf l is unconstrained in all sections, it can be inserted anywhere
+				if dd == d:
+					for m in range(l):
+						gap[gg] = m
+						gg += 1
+
+				# Filter gaps that are common to all sections
+				for j in range(g, gg):
+					gap[g] = gap[j]
+					if count[gap[j]] == d - dd:
+						g += 1
+					count[gap[j]] = 0  # Reset count for next iteration
+
+		# Recursive backtracking steps
+		while l > 0 and g == gapter[l - 1]:
+			l -= 1
+			B[A[l]] = B[l]
+			A[B[l]] = A[l]
+
+		if l > 0:
+			g -= 1
+			A[l] = gap[g]
+			B[l] = B[A[l]]
+			B[A[l]] = l
+			A[B[l]] = l
+			gapter[l] = g  # Save current gap index
+			l += 1		 # Move to next leaf
+
+	return total_count

mapFolding/someAssemblyRequired/__init__.py

@@ -1 +1,2 @@
-from .makeJob import makeStateJob
+from mapFolding.someAssemblyRequired.getLLVMforNoReason import writeModuleLLVM
+from mapFolding.someAssemblyRequired.makeJob import makeStateJob

mapFolding/someAssemblyRequired/getLLVMforNoReason.py

@@ -4,16 +4,16 @@ import llvmlite.binding
 import pathlib
 
 def writeModuleLLVM(pathFilename: pathlib.Path, identifierCallable: str) -> pathlib.Path:
-    """Import the generated module directly and get its LLVM IR."""
-    specTarget = importlib.util.spec_from_file_location("generatedModule", pathFilename)
-    if specTarget is None or specTarget.loader is None:
-        raise ImportError(f"Could not create module spec or loader for {pathFilename}")
-    moduleTarget = importlib.util.module_from_spec(specTarget)
-    specTarget.loader.exec_module(moduleTarget)
+	"""Import the generated module directly and get its LLVM IR."""
+	specTarget = importlib.util.spec_from_file_location("generatedModule", pathFilename)
+	if specTarget is None or specTarget.loader is None:
+		raise ImportError(f"Could not create module spec or loader for {pathFilename}")
+	moduleTarget = importlib.util.module_from_spec(specTarget)
+	specTarget.loader.exec_module(moduleTarget)
 
-    # Get LLVM IR and write to file
-    linesLLVM = moduleTarget.__dict__[identifierCallable].inspect_llvm()[()]
-    moduleLLVM = llvmlite.binding.module.parse_assembly(linesLLVM)
-    pathFilenameLLVM = pathFilename.with_suffix(".ll")
-    pathFilenameLLVM.write_text(str(moduleLLVM))
-    return pathFilenameLLVM
+	# Get LLVM IR and write to file
+	linesLLVM = moduleTarget.__dict__[identifierCallable].inspect_llvm()[()]
+	moduleLLVM = llvmlite.binding.module.parse_assembly(linesLLVM)
+	pathFilenameLLVM = pathFilename.with_suffix(".ll")
+	pathFilenameLLVM.write_text(str(moduleLLVM))
+	return pathFilenameLLVM

mapFolding/someAssemblyRequired/makeJob.py

@@ -6,56 +6,56 @@ import pickle
 
 @overload
 def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[True]
-                 , **keywordArguments: Optional[str]) -> pathlib.Path:
-    ...
+				 , **keywordArguments: Optional[str]) -> pathlib.Path:
+	...
 
 @overload
 def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[False]
-                 , **keywordArguments: Optional[str]) -> computationState:
-    ...
+				 , **keywordArguments: Optional[str]) -> computationState:
+	...
 
 def makeStateJob(listDimensions: Sequence[int], *, writeJob: bool = True, **keywordArguments: Optional[Any]) -> computationState | pathlib.Path:
-    """
-    Creates a computation state job for map folding calculations and optionally saves it to disk.
-
-    This function initializes a computation state for map folding calculations based on the given dimensions,
-    sets up the initial counting configuration, and can optionally save the state to a pickle file.
-
-    Parameters
-    ----------
-    listDimensions : Sequence[int]
-        The dimensions of the map to be folded, typically as [height, width].
-    writeJob : bool, optional
-        If True, saves the computation state to disk. If False, returns the state object directly.
-        Default is True.
-    **keywordArguments : Optional[str]
-        Additional keyword arguments to be passed to the outfitCountFolds function.
-
-    Returns
-    -------
-    Union[computationState, pathlib.Path]
-        If writeJob is False, returns the computation state object.
-        If writeJob is True, returns the Path object pointing to the saved state file.
-
-    Notes
-    -----
-    The function creates necessary directories and saves the state as a pickle file
-    when writeJob is True. The file is saved in a directory structure based on the map shape.
-    """
-
-    stateUniversal: computationState = outfitCountFolds(listDimensions, **keywordArguments)
-
-    moduleSource: ModuleType = getAlgorithmSource()
-    moduleSource.countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['track'])
-
-    if not writeJob:
-        return stateUniversal
-
-    pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])
-    suffix = pathFilenameChopChop.suffix
-    pathJob = pathlib.Path(str(pathFilenameChopChop)[0:-len(suffix)])
-    pathJob.mkdir(parents=True, exist_ok=True)
-    pathFilenameJob = pathJob / 'stateJob.pkl'
-
-    pathFilenameJob.write_bytes(pickle.dumps(stateUniversal))
-    return pathFilenameJob
+	"""
+	Creates a computation state job for map folding calculations and optionally saves it to disk.
+
+	This function initializes a computation state for map folding calculations based on the given dimensions,
+	sets up the initial counting configuration, and can optionally save the state to a pickle file.
+
+	Parameters
+	----------
+	listDimensions : Sequence[int]
+		The dimensions of the map to be folded, typically as [height, width].
+	writeJob : bool, optional
+		If True, saves the computation state to disk. If False, returns the state object directly.
+		Default is True.
+	**keywordArguments : Optional[str]
+		Additional keyword arguments to be passed to the outfitCountFolds function.
+
+	Returns
+	-------
+	Union[computationState, pathlib.Path]
+		If writeJob is False, returns the computation state object.
+		If writeJob is True, returns the Path object pointing to the saved state file.
+
+	Notes
+	-----
+	The function creates necessary directories and saves the state as a pickle file
+	when writeJob is True. The file is saved in a directory structure based on the map shape.
+	"""
+
+	stateUniversal: computationState = outfitCountFolds(listDimensions, **keywordArguments)
+
+	moduleSource: ModuleType = getAlgorithmSource()
+	moduleSource.countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['track'])
+
+	if not writeJob:
+		return stateUniversal
+
+	pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])
+	suffix = pathFilenameChopChop.suffix
+	pathJob = pathlib.Path(str(pathFilenameChopChop)[0:-len(suffix)])
+	pathJob.mkdir(parents=True, exist_ok=True)
+	pathFilenameJob = pathJob / 'stateJob.pkl'
+
+	pathFilenameJob.write_bytes(pickle.dumps(stateUniversal))
+	return pathFilenameJob

mapFolding/someAssemblyRequired/synthesizeModuleJAX.py

@@ -6,24 +6,24 @@ import inspect
 import pathlib
 import sys
 
-def transformPythonToJAX(codePython: str):
-    astPython = ast.parse(codePython)
+def transformPythonToJAX(codePython: str) -> None:
+	astPython = ast.parse(codePython)
 
 def writeJax(*, codeSource: Optional[str] = None, pathFilenameAlgorithm: Optional[pathlib.Path] = None, pathFilenameDestination: Optional[pathlib.Path] = None) -> None:
-    if codeSource is None and pathFilenameAlgorithm is None:
-        algorithmSource = getAlgorithmSource()
-        codeSource = inspect.getsource(algorithmSource)
-        transformedText = transformPythonToJAX(codeSource)
-        pathFilenameAlgorithm = pathlib.Path(inspect.getfile(algorithmSource))
-    else:
-        raise NotImplementedError("You haven't written this part yet.")
-    if pathFilenameDestination is None:
-        pathFilenameDestination = getPathSyntheticModules() / "countJax.py"
-    # pathFilenameDestination.write_text(transformedText)
+	if codeSource is None and pathFilenameAlgorithm is None:
+		algorithmSource = getAlgorithmSource()
+		codeSource = inspect.getsource(algorithmSource)
+		transformedText = transformPythonToJAX(codeSource)
+		pathFilenameAlgorithm = pathlib.Path(inspect.getfile(algorithmSource))
+	else:
+		raise NotImplementedError("You haven't written this part yet.")
+	if pathFilenameDestination is None:
+		pathFilenameDestination = getPathSyntheticModules() / "countJax.py"
+	# pathFilenameDestination.write_text(transformedText)
 
 if __name__ == '__main__':
-    setDatatypeModule('jax.numpy', sourGrapes=True)
-    setDatatypeFoldsTotal('int64', sourGrapes=True)
-    setDatatypeElephino('uint8', sourGrapes=True)
-    setDatatypeLeavesTotal('uint8', sourGrapes=True)
-    writeJax()
+	setDatatypeModule('jax.numpy', sourGrapes=True)
+	setDatatypeFoldsTotal('int64', sourGrapes=True)
+	setDatatypeElephino('uint8', sourGrapes=True)
+	setDatatypeLeavesTotal('uint8', sourGrapes=True)
+	writeJax()