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 Data.Bifunctor (first)

import Data.Bool (bool)

 

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 =

let cws = ((,) . coverage <*> weight) . rootLabel <$> xs

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

 

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

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}}

</pre>

=={{header|Lua}}==

local function node(name, weight, coverage, children)

return { name=name, weight=weight or 1.0, coverage=coverage or 0.0, sumofweights=0, delta=0, children=children }

end

print("NAME_HIERARCHY |WEIGHT |COVERAGE |DELTA |")

{{out}}

<pre>NAME_HIERARCHY |WEIGHT |COVERAGE |DELTA |

wine_cellar | 1 | 1.000000 | 0.000000 |

cinema | 1 | 0.750000 | 0.016667 |</pre>

 

=={{header|Perl}}==

use warnings;

 

wine_cellar | |1 |

cinema | |0.75 |

{{out}}

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

 

=={{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

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}}

(formerly Perl 6)

{{trans|Perl}}

my (@parts, $cnt);

 

cinema | |0.75 |

END

{{out}}

<pre style="font-size:70%;">NAME_HIERARCHY |WEIGHT |COVERAGE |

{{trans|Kotlin}}

 

 

extension String {

print("\nIf the coverage of the Cinema node were increased from 0.75 to 1.0")

print("the top level coverage would increase by ")

 

{{out}}

{{trans|Kotlin}}

{{libheader|Wren-fmt}}

 

class FCNode {

System.write("the top level coverage would increase by ")

Fmt.print("$8.6f to $8.6f", diff, topCoverage + diff)

 

{{out}}