Functional coverage tree: Difference between revisions

=={{header|Go}}==

{{trans|Kotlin}}

 

import "fmt"

fmt.Printf("%8.6f to %8.6f\n", diff, topCoverage+diff)

h2Basement[2].setCoverage(0.75) // restore to original value if required

 

{{out}}

The raw table (supplied in the task description) is read in from a text file, parsed to a tree structure, and updated by two traversals (one bottom-up and one top down) before being serialised back to a completed outline text, with an additional 'Share of Residue' column:

{{Trans|Python}}

 

import qualified Data.Text as T

import Numeric (showFFloat)

 

data Coverage = Coverage

 

fp = "./coverageOutline.txt"

 

main :: IO ()

main =

 

updatedCoverageOutline :: T.Text -> T.Text

updatedCoverageOutline s =

let delimiter = "|"

indentedLines = T.lines s

 

weightedCoverage x xs =

totalWeight = foldr ((+) . snd) 0 cws

 

withResidueShares :: Float -> Tree Coverage -> Tree Coverage

let go fraction node =

let forest = subForest node

weightTotal = sum weights

nodeRoot = rootLabel node

 

parseTreeFromOutline :: T.Text -> [T.Text] -> Tree Coverage

parseTreeFromOutline delimiter indentedLines =

 

forestFromLineIndents :: [(Int, T.Text)] -> [Tree T.Text]

forestFromLineIndents pairs =

let go [] = []

let (firstTreeLines, rest) = span ((n <) . fst) xs

 

indentLevelsFromLines :: [T.Text] -> [(Int, T.Text)]

indentUnit =

foldr

let w = (T.length . fst) x

(maxBound :: Int)

pairs

 

partialRecord :: [T.Text] -> Coverage

partialRecord xs =

 

defaultOrRead :: Float -> T.Text -> Float

tokenizeWith delimiter = fmap T.strip . T.splitOn delimiter

 

indentedLinesFromTree tab showRoot tree =

let go indent node =

showRoot indent (rootLabel node) :

(subForest node >>= go (T.append tab indent))

 

showCoverage :: T.Text -> T.Text -> Coverage -> T.Text

tabulation

delimiter

 

tabulation :: T.Text -> [T.Text] -> T.Text

tabulation delimiter =

 

justifyRight :: Int -> a -> [a] -> [a]

 

showN :: Int -> Float -> String

{{Out}}

<pre>NAME_HIERARCHY | WEIGHT | COVERAGE | SHARE OF RESIDUE

Implementation part 1 of 4 (raw data):

 

NAME_HIERARCHY |WEIGHT |COVERAGE |

cleaning | | |

wine_cellar | |1 |

cinema | |0.75 |

 

Implementation part 2 of 4 (unpacking raw data):

 

'hier wspec cspec'=:|:}.<;._2;._2 raw

level=: (%+./) (0 i.~' '&=)"1 hier

weight=: (+ 0=]) ,".wspec

 

To understand this implementation, it's best to run it and inspect the data.

Implementation part 3 of 4 (translation of leaf coverage to functional coverage):

 

unrooted=: ([: merge <@(_1,$:@}.);.1)^:(0<#)

parent=: unrooted level

 

<code>unrooted</code> translates indentation information to a [[Tree_traversal#J:_Alternate_implementation|parent tree structure]]. However, the limitations of recursion require we distinguish the parent node from its children, so we use _1 to denote the parent node of the recursive intermediate result unrooted trees. (This works well with using arithmetic to adjust sub-tree indices based on the lengths of preceding sub-trees.) <code>merge</code> combines a boxed sequence of these subtrees to form a single tree - we also rely on the first node of each tree being both _1 and the root node.

Task example part 4 of 4 (format and show result):

 

NAME_HIERARCHY │WEIGHT │COVERAGE │

cleaning │ 1 │0.409167 │

cellars │ 1 │ 1 │

wine_cellar │ 1 │ 1 │

 

Extra credit:

 

power=: */@:{&(parent (] % (i.~ ~.)@[ { +//.) weight)@> trace

 

power*1-weight parent_cover coverage

 

Explanation:

 

And, <code>weight parent_cover coverage</code> was the functional coverage for each node.

 

=={{header|JavaScript}}==

{{Trans|Haskell}}

{{Trans|Python}}

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>NAME_HIERARCHY | WEIGHT | COVERAGE | SHARE OF RESIDUE

Most implementations of functional coverage are going to store values in a database. The implementation

stores the tree in a CSV file with an index to the parent of each entry to allow reconstitution of the tree.

 

function updatecoverage(dfname, outputname)

println("\nUpdated data:")

displaycoveragedb(newdbname)

<pre>

Input data:

 

=={{header|Kotlin}}==

 

class FCNode(val name: String, val weight: Int = 1, coverage: Double = 0.0) {

println("${"%8.6f".format(diff)} to ${"%8.6f".format(topCoverage + diff)}")

h2Basement[2].coverage = 0.75 // restore to original value if required

 

{{out}}

the top level coverage would increase by 0.016667 to 0.425833

</pre>

 

=={{header|Perl}}==

use warnings;

 

wine_cellar | |1 |

cinema | |0.75 |

{{out}}

<pre style="height:20ex" style="font-size:80%;">NAME_HIERARCHY |WEIGHT |COVERAGE |

cleaning |1 |0.41 |

house1 |40 |0.33 |

 

=={{header|Phix}}==

{{out}}

<pre>

It's actually some of the raw code used when researching this task.

 

 

 

print('\n\nTOP COVERAGE = %f\n' % covercalc(lstc))

depth_first(lstc)

 

{{out}}

A cleaner implementation that uses the class static variable path2node as in the previous example so you don't have to traverse the tree to work out the position to add new nodes. This relies on parent nodes appearing before their children which is the case in the order of the add_node calls.

 

 

SPACES = 4

assert isclose((delta + cover), 1.0), "Top level delta + coverage should " \

"equal 1 instead of (%f + %f)" % (delta, cover)

 

{{out}}

Mainly uses pre-existing generic functions, including '''forestFromLineIndents''', '''foldTree''' and '''fmapTree''':

{{Works with|Python|3.7}}

 

from itertools import chain, product

delimiter = '|'

 

columnTitles = init(columnNames(delimiter)(reportLines[0]))

 

print(titleLine(delimiter)(columnWidths)(

columnTitles + ['share of residue']

print(indentedLinesFromTree(' ', tabulation(columnWidths))(

 

withResidueShares(1.0)(

foldTree(weightedCoverage)(

 

fmapTree(

)(

)

)

 

 

 

# weightedCoverage :: Tree Dict ->

'''

def go(xs):

totalWeight = reduce(lambda a, x: a + x[1], cws, 0)

return Node(dict(

}

))(xs)

 

 

'''

def go(fraction, node):

weights = [root(x)['weight'] for x in nodeNest]

siblingsTotal = sum(weights)

 

 

 

# tabulation :: [Int] -> String -> Dict -> String

 

 

 

# Node :: a -> [Tree a] -> Tree a

 

 

'''The application of each of a list of functions,

to each of a list of values.

'''

 

 

# concatMap :: (a -> [b]) -> [a] -> [b]

def concatMap(f):

'''

 

 

 

 

'''

 

 

def fmapTree(f):

'''A new tree holding the results of

the existing tree.

'''

def go(x):

 

 

def foldTree(f):

'''The catamorphism on trees. A summary

'''

def go(node):

])

 

 

with integers giving their levels of indentation.

'''

def go(xs):

if xs:

)(xs[1:])

else:

return []

'''First member of a pair.'''

return tpl[0]

 

 

'''

indentTextPairs = list(map(

xs

))

)(indentTextPairs))

return list(map(

indentTextPairs

))

'''

def go(indent):

 

 

'''

return s.isspace()

 

 

span p xs is equivalent to (takeWhile p xs, dropWhile p xs).

'''

def go(xs):

 

 

# splitOn :: String -> String -> [String]

def splitOn(pat):

return lambda xs: (

xs.split(pat) if isinstance(xs, str) else None

)

 

'''String in lower case.'''

return s.lower()

 

 

The initial seed value is x.

'''

 

 

wine_cellar | |1 |

cinema | |0.75 |'''

{{Out}}

<pre>NAME_HIERARCHY | WEIGHT | COVERAGE | SHARE OF RESIDUE

(in this case <code>data/functional-coverage.txt</code>).

 

(require racket/list racket/string racket/match racket/format racket/file)

 

(for-each

(compose print-coverage-tree find-wght-cvrg)

 

{{out}}

| wine_cellar | 1 | 1.00 | 1.00000 |

| cinema | 1 | 0.75 | 0.75000 |</pre>