Ejemplo n.º 1
0
    def testCauchit(self):
        engine, = PFAEngine.fromYaml("""
input: double
output: double
action: {m.link.cauchit: input}
""")
        self.assertAlmostEqual(engine.action(2.2), 0.8642002512199081, places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: array, items: double}
output: {type: array, items: double}
action: {m.link.cauchit: input}
""")
        out = engine.action([1, 2, 3, 4])
        self.assertAlmostEqual(out[0], 0.75              , places = 5)
        self.assertAlmostEqual(out[1], 0.8524163823495667, places = 5)
        self.assertAlmostEqual(out[2], 0.8975836176504333, places = 5)
        self.assertAlmostEqual(out[3], 0.9220208696226307, places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: map, values: double}
output: {type: map, values: double}
action: {m.link.cauchit: input}
""")
        out = engine.action({"one": 1, "two": 2, "three": 3, "four": 4})
        self.assertAlmostEqual(out["one"],   0.75              , places = 5)
        self.assertAlmostEqual(out["two"],   0.8524163823495667, places = 5)
        self.assertAlmostEqual(out["three"], 0.8975836176504333, places = 5)
        self.assertAlmostEqual(out["four"],  0.9220208696226307, places = 5)
Ejemplo n.º 2
0
    def testMakeTimestamp(self):
        engine, = PFAEngine.fromYaml("""
input: int
output: double
action:
  - {time.makeTimestamp: [input, 3, 11, 14, 50, 6, 245, {string: ""}]}
""")
        self.assertEqual(engine.action(2015), 1426085406.245)

        engine2, = PFAEngine.fromYaml("""
input: int
output: double
action:
  - {time.makeTimestamp: [input, 1, 1, 0, 0, 0, 0, {string: ""}]}
""")
        self.assertEqual(engine2.action(1970), 0)

        engine3, = PFAEngine.fromYaml("""
input: string
output: double
action:
  - {time.makeTimestamp: [1970, 1, 1, 0, 0, 0, 0, input]}
""")
        self.assertEqual(engine3.action("Europe/Paris"), -3600)
        self.assertEqual(engine3.action("Etc/UTC"), 0)
        self.assertEqual(engine3.action("Atlantic/Azores"), 3600)
Ejemplo n.º 3
0
    def testNChooseKFcn(self):
        engine, = PFAEngine.fromYaml('''
input: int
output: int
action:
  - m.special.nChooseK: [input, 2]
''')
        self.assertEqual(engine.action(20),    190)
        self.assertEqual(engine.action(10),     45)
        self.assertEqual(engine.action(3),       3)

    ### raise the right exceptions ###
        engine, = PFAEngine.fromYaml('''
input: int
output: int
action:
  - m.special.nChooseK: [input, 4]
''')
        self.assertRaises(PFARuntimeException, lambda: engine.action(1))
        self.assertRaises(PFARuntimeException, lambda: engine.action(0))

        engine, = PFAEngine.fromYaml('''
input: int
output: int
action:
  - m.special.nChooseK: [input, -4] #[input, lambda]
''')
        self.assertRaises(PFARuntimeException, lambda: engine.action(-2))
Ejemplo n.º 4
0
    def testDoAbs(self):
        engine, = PFAEngine.fromYaml('''
input: double
output: double
action:
  - {m.abs: input}
''')
        self.assertAlmostEqual(engine.action(-3.14), 3.14, places=2)

        engine, = PFAEngine.fromYaml('''
input: int
output: int
action:
  - {m.abs: input}
''')
        self.assertEqual(engine.action(2147483647), 2147483647)
        self.assertEqual(engine.action(-2147483647), 2147483647)
        self.assertRaises(PFARuntimeException, lambda: engine.action(-2147483648))

        engine, = PFAEngine.fromYaml('''
input: long
output: long
action:
  - {m.abs: input}
''')
        self.assertEqual(engine.action(9223372036854775807), 9223372036854775807)
        self.assertEqual(engine.action(-9223372036854775807), 9223372036854775807)
        self.assertRaises(PFARuntimeException, lambda: engine.action(-9223372036854775808))
Ejemplo n.º 5
0
    def testRegMahalanobis(self):
        engine, = PFAEngine.fromYaml("""
input: {type: array, items: double}
output: double
action:
  stat.test.mahalanobis:
    - input
    - type: {type: array, items: double}
      value: [2.5, 2.5, 2.5]
    - type: {type: array, items: {type: array, items: double}}
      value: [[2.0, 0.0, 0.0],
              [0.0, 4.0, 0.0],
              [0.0, 0.0, 1.0]]
""")
        self.assertAlmostEqual(engine.action([1, 2, 3]), 1.19895788083, places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: map, values: double}
output: double
action:
  stat.test.mahalanobis:
    - input
    - type: {type: map, values: double}
      value: {one: 2.5, two: 2.5, three: 2.5}
    - type: {type: map, values: {type: map, values: double}}
      value: {one:   {one: 2.0, two: 0.0, three: 0.0},
              two:   {one: 0.0, two: 4.0, three: 0.0},
              three: {one: 0.0, two: 0.0, three: 1.0}}
""")
        self.assertAlmostEqual(engine.action({"one": 1, "two": 2, "three": 3}), 1.19895788083, places = 5)
Ejemplo n.º 6
0
    def testSoftPlus(self):
        engine, = PFAEngine.fromYaml("""
input: double
output: double
action: {m.link.softplus: input}
""")
        self.assertAlmostEqual(engine.action(2.2), 2.305083319768696, places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: array, items: double}
output: {type: array, items: double}
action: {m.link.softplus: input}
""")
        out = engine.action([1, 2, 3, 4])
        self.assertAlmostEqual(out[0], 1.31326168752 , places = 5)
        self.assertAlmostEqual(out[1], 2.12692801104 , places = 5)
        self.assertAlmostEqual(out[2], 3.04858735157 , places = 5)
        self.assertAlmostEqual(out[3], 4.01814992792 , places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: map, values: double}
output: {type: map, values: double}
action: {m.link.softplus: input}
""")
        out = engine.action({"one": 1, "two": 2, "three": 3, "four": 4})
        self.assertAlmostEqual(out["one"],   1.31326168752, places = 5)
        self.assertAlmostEqual(out["two"],   2.12692801104, places = 5)
        self.assertAlmostEqual(out["three"], 3.04858735157, places = 5)
        self.assertAlmostEqual(out["four"],  4.01814992792, places = 5)
Ejemplo n.º 7
0
    def testDoMin(self):
        engine, = PFAEngine.fromYaml('''
input: double
output: double
action:
  - {min: [input, 3.2]}
''')
        self.assertEqual(engine.action(2.2), 2.2)
        self.assertEqual(engine.action(4.2), 3.2)

        engine, = PFAEngine.fromYaml('''
input: int
output: int
action:
  - {min: [input, 3]}
''')
        self.assertEqual(engine.action(2), 2)
        self.assertEqual(engine.action(4), 3)

        engine, = PFAEngine.fromYaml('''
input: string
output: string
action:
  - {min: [input, [HAL]]}
''')
        self.assertEqual(engine.action("GZK"), "GZK")
        self.assertEqual(engine.action("IBM"), "HAL")
Ejemplo n.º 8
0
    def testCloglog(self):
        engine, = PFAEngine.fromYaml("""
input: double
output: double
action: {m.link.cloglog: input}
""")
        self.assertAlmostEqual(engine.action(2.2), 0.9998796388196516, places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: array, items: double}
output: {type: array, items: double}
action: {m.link.cloglog: input}
""")
        out = engine.action([1, 2, 3, 4])
        self.assertAlmostEqual(out[0], 0.9340119641546875, places = 5)
        self.assertAlmostEqual(out[1], 0.9993820210106689, places = 5)
        self.assertAlmostEqual(out[2], 0.9999999981078213, places = 5)
        self.assertAlmostEqual(out[3], 1.0               , places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: map, values: double}
output: {type: map, values: double}
action: {m.link.cloglog: input}
""")
        out = engine.action({"one": 1, "two": 2, "three": 3, "four": 4})
        self.assertAlmostEqual(out["one"],   0.9340119641546875, places = 5)
        self.assertAlmostEqual(out["two"],   0.9993820210106689, places = 5)
        self.assertAlmostEqual(out["three"], 0.9999999981078213, places = 5)
        self.assertAlmostEqual(out["four"],  1.0               , places = 5)
Ejemplo n.º 9
0
    def testBitwiseOperators(self):
        engine, = PFAEngine.fromYaml('''
input: "null"
output: int
action:
  - {"&": [85, 15]}
''')
        self.assertEqual(engine.action(None), 5)

        engine, = PFAEngine.fromYaml('''
input: "null"
output: int
action:
  - {"|": [85, 15]}
''')
        self.assertEqual(engine.action(None), 95)

        engine, = PFAEngine.fromYaml('''
input: "null"
output: int
action:
  - {"^": [85, 15]}
''')
        self.assertEqual(engine.action(None), 90)

        engine, = PFAEngine.fromYaml('''
input: "null"
output: int
action:
  - {"~": [85]}
''')
        self.assertEqual(engine.action(None), -86)
Ejemplo n.º 10
0
    def testDoCmp(self):
        engine, = PFAEngine.fromYaml('''
input: int
output: int
action:
  - {cmp: [input, 5]}
''')
        self.assertEqual(engine.action(3), -1)
        self.assertEqual(engine.action(5), 0)
        self.assertEqual(engine.action(7), 1)

        engine, = PFAEngine.fromYaml('''
input: double
output: int
action:
  - {cmp: [input, 5.3]}
''')
        self.assertEqual(engine.action(5.2), -1)
        self.assertEqual(engine.action(5.3), 0)
        self.assertEqual(engine.action(5.4), 1)

        engine, = PFAEngine.fromYaml('''
input: string
output: int
action:
  - {cmp: [input, [HAL]]}
''')
        self.assertEqual(engine.action("GZK"), -1)
        self.assertEqual(engine.action("HAL"), 0)
        self.assertEqual(engine.action("IBM"), 1)
Ejemplo n.º 11
0
    def testRejectComparisonsBetweenDifferentTypesEvenIfTheyHaveTheSameStructure(self):
        engine, = PFAEngine.fromYaml('''
input: {type: enum, name: Category1, symbols: [z, y, x, w]}
output: boolean
action:
  - {"==": [input, {type: Category1, value: x}]}
''')
        self.assertFalse(engine.action("z"))
        self.assertFalse(engine.action("y"))
        self.assertTrue(engine.action("x"))
        self.assertFalse(engine.action("w"))

        self.assertRaises(PFASemanticException, lambda: PFAEngine.fromYaml('''
input: {type: enum, name: Category1, symbols: [z, y, x, w]}
output: boolean
action:
  - {"==": [input, {type: {type: enum, name: Category2, symbols: [w, x, y, z]}, value: x}]}
'''))

        self.assertRaises(PFASemanticException, lambda: PFAEngine.fromYaml('''
input: {type: enum, name: Category1, symbols: [z, y, x, w]}
output: boolean
action:
  - {"==": [input, {type: {type: enum, name: Category2, symbols: [w, x, y, whatever]}, value: x}]}
'''))
Ejemplo n.º 12
0
    def testBin(self):
        engine1, = PFAEngine.fromYaml('''
input: double
output: int
action:
  interp.bin: [input, 5, 100, 110]
''')
        self.assertEqual(engine1.action(100.0), 0)
        self.assertEqual(engine1.action(101.0), 0)
        self.assertEqual(engine1.action(101.999), 0)
        self.assertEqual(engine1.action(102.0), 1)
        self.assertEqual(engine1.action(109.999), 4)

        engine2, = PFAEngine.fromYaml('''
input: double
output: int
action:
  interp.bin: [input, 100, 2]
''')
        self.assertEqual(engine2.action(99.0), -1)
        self.assertEqual(engine2.action(99.999), -1)
        self.assertEqual(engine2.action(100.0), 0)
        self.assertEqual(engine2.action(101.0), 0)
        self.assertEqual(engine2.action(101.999), 0)
        self.assertEqual(engine2.action(102.0), 1)
        self.assertEqual(engine2.action(109.999), 4)
        self.assertEqual(engine2.action(110.0), 5)
        self.assertEqual(engine2.action(0.0), -50)
Ejemplo n.º 13
0
    def testDoExponentiation(self):
        engine, = PFAEngine.fromYaml('''
input: double
output: double
action:
  - {"**": [input, 30]}
''')
        self.assertAlmostEqual(engine.action(2.5), 867361737988.4036, places=2)

        engine, = PFAEngine.fromYaml('''
input: int
output: int
action:
  - {"**": [input, 30]}
''')
        self.assertEqual(engine.action(2), 1073741824)

        engine, = PFAEngine.fromYaml('''
input: int
output: int
action:
  - {"**": [input, 30]}
''')
        self.assertRaises(PFARuntimeException, lambda: engine.action(3))

        engine, = PFAEngine.fromYaml('''
input: long
output: long
action:
  - {"**": [input, 30]}
''')
        self.assertEqual(engine.action(3), 205891132094649)
Ejemplo n.º 14
0
    def testgroupsAll(self):
        engine, = PFAEngine.fromYaml("""
input: string
output: {type: array, items: {type: array, items: {type: array, items: int}}}
action:
  - {re.groupsall: [input, [()(a)bc(def)ghijk]]}
""")
        self.assertEqual(engine.action("abcdefghijkMMMMMabcdefghijkMMMM"), [[[0,11], [0,0], [0,1], [3,6]], [[16, 27],[16,16],[16,17], [19,22]]])

## check non-ascii input
#        engine, = PFAEngine.fromYaml("""
#input: string
#output: {type: array, items: {type: array, items: {type: array, items: int}}}
#action:
#  - {re.groupsall: [input, [(机)机]]}
#""")
#        self.assertEqual(engine.action("abc机机abca机机bc"), [[[3,5], [3,4]], [[9,11], [9,10]]])

# check byte input
        engine, = PFAEngine.fromYaml("""
input: bytes
output: {type: array, items: {type: array, items: {type: array, items: int}}}
action:
  - re.groupsall: [input, {bytes.encodeUtf8: {string: "(机)机"}}]
""")
        self.assertEqual(engine.action("abc机机abca机机bc"), [[[3,9], [3,6]], [[13,19], [13,16]]])
Ejemplo n.º 15
0
    def testfindFirst(self):
        engine, = PFAEngine.fromYaml("""
input: string
output: [string, "null"]
action:
  - {re.findfirst: [input, [ab]]}
""")
        self.assertEqual(engine.action("88ccc555"),  None)
        self.assertEqual(engine.action("abcabcabc"), "ab")

# check non-ascii input
#        engine, = PFAEngine.fromYaml("""
#input: string
#output: [string, "null"]
#action:
#  - {re.findfirst: [input, [机机+]]}
#""")
#        self.assertEqual(engine.action("abc机机机abca机机bc  asdkj 机机机sd"), "机机机")
#        self.assertEqual(engine.action("abdefg"), None)

# check byte input
        engine, = PFAEngine.fromYaml("""
input: bytes
output: [bytes, "null"]
action:
  - re.findfirst: [input, {bytes.encodeUtf8: {string: "对讲机(讲|机)*"}}]
""")
        self.assertEqual(engine.action("abcde对讲机讲fgg对讲机讲h"), "对讲机讲")
        self.assertEqual(engine.action("abcdefghijk"), None)
Ejemplo n.º 16
0
    def testBytes(self):
        engine1, = PFAEngine.fromYaml('''
input: "null"
output: bytes
randseed: 12345
action: {rand.bytes: [10]}
''')
        self.assertEqual(engine1.action(None), "j\x02\xd3L^1\x90)\x1fn")
        self.assertEqual(engine1.action(None), "\x8f,\x8dZ\xf5\x17\xfai\x81%")
        self.assertEqual(engine1.action(None), "\xb80W\x06V\xf7\xfa\xbe\x00\xf0")

        engine2, = PFAEngine.fromYaml('''
input: "null"
output: bytes
randseed: 12345
action: {rand.bytes: [10, {base64: "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5"}]}

''')
        self.assertEqual(engine2.action(None), "oa3kngufep")
        self.assertEqual(engine2.action(None), "ugtm8d9osf")
        self.assertEqual(engine2.action(None), "zgmam890a7")

        engine3, = PFAEngine.fromYaml('''
input: "null"
output: bytes
randseed: 12345
action: {rand.bytes: [10, 33, 127]}
''')
        self.assertEqual(engine3.action(None), "H!n=C3V0,I")
        self.assertEqual(engine3.action(None), "U1UB{)|GP.")
        self.assertEqual(engine3.action(None), "d2A#@{}f!y")
Ejemplo n.º 17
0
    def testUUID(self):
        engine1, = PFAEngine.fromYaml('''
input: "null"
output: string
randseed: 12345
action: {rand.uuid4: []}
''')
        self.assertEqual(engine1.action(None), "6aa79987-bb91-4029-8d1f-cd8778e7d340bbcd")
        self.assertEqual(engine1.action(None), "4c73a942-daea-45e5-8ee8-452ec40a3193ca54")
        self.assertEqual(engine1.action(None), "90e5e945-6fac-4296-85f8-dfc9e3b11fcff454")

        engine2, = PFAEngine.fromYaml('''
input: "null"
output: string
action: {s.substr: [{rand.uuid4: []}, 14, 15]}
''')
        for i in xrange(1000):
            self.assertEqual(engine2.action(None), "4")

        engine3, = PFAEngine.fromYaml('''
input: "null"
output: string
action: {s.substr: [{rand.uuid4: []}, 19, 20]}
''')
        for i in xrange(1000):
            self.assertEqual(engine3.action(None), "8")
Ejemplo n.º 18
0
    def testreplaceLast(self):
        engine, = PFAEngine.fromYaml("""
input: string
output: string
action:
  - {re.replacelast: [input, ["ab(c|d)*"], ["person"]]}
""")
        self.assertEqual(engine.action("abcccdcPPPPabcccdc"),     "abcccdcPPPPperson")
        self.assertEqual(engine.action("abcccdcPPPPabcccdcPPPP"), "abcccdcPPPPpersonPPPP")

# check non-ascii input
#        engine, = PFAEngine.fromYaml("""
#input: string
#output: string
#action:
#  - {re.replacelast: [input, [对讲机+], ["walkie talkie"]]}
#""")
#        self.assertEqual(engine.action("This 对讲机 works better than that 对讲机."), "This 对讲机 works better than that walkie talkie.")

# check byte input
        engine, = PFAEngine.fromYaml("""
input: bytes
output: bytes
action:
  - {re.replacelast: [input, {bytes.encodeUtf8: {string: "对讲机+"}}, {bytes.encodeUtf8: {string: "walkie talkie"}}]}
""")
        self.assertEqual(engine.action("This 对讲机 works better than that 对讲机."), "This 对讲机 works better than that walkie talkie.")
Ejemplo n.º 19
0
        def bad():
            PFAEngine.fromYaml('''
input: [int, string, "null"]
output: int
action:
  - {impute.defaultOnNull: [input, 12]}
''')
Ejemplo n.º 20
0
    def testString(self):
        engine1, = PFAEngine.fromYaml('''
input: "null"
output: string
randseed: 12345
action: {rand.string: [10]}
''')
        self.assertEqual(engine1.action(None), u"姾ȳ눿䂂侔⧕穂⋭᫘嶄")
        self.assertEqual(engine1.action(None), u"祩▩睿䲩컲Ꮉ퍣夅泚 ")
        self.assertEqual(engine1.action(None), u"魍⤉䧇ԕ䥖탺퍬ꃒÀ쬘")

        engine2, = PFAEngine.fromYaml('''
input: "null"
output: string
randseed: 12345
action: {rand.string: [10, {string: "abcdefghijklmnopqrstuvwxyz0123456789"}]}
''')
        self.assertEqual(engine2.action(None), "oa3kngufep")
        self.assertEqual(engine2.action(None), "ugtm8d9osf")
        self.assertEqual(engine2.action(None), "zgmam890a7")

        engine3, = PFAEngine.fromYaml('''
input: "null"
output: string
randseed: 12345
action: {rand.string: [10, 33, 127]}
''')
        self.assertEqual(engine3.action(None), "H!n=C3V0,I")
        self.assertEqual(engine3.action(None), "U1UB{)|GP.")
        self.assertEqual(engine3.action(None), "d2A#@{}f!y")
Ejemplo n.º 21
0
    def testScaleMaps(self):
        engine, = PFAEngine.fromYaml('''
input: "null"
output: {type: map, values: double}
action:
  la.scale:
    - type: {type: map, values: double}
      value: {one: 1, two: 2, three: 3, four: 4, five: 5}
    - 10
''')
        self.assertAlmostEqual(self.chi2Vector(engine.action(None),
            {"one": 10.0, "two": 20.0, "three": 30.0, "four": 40.0, "five": 50.0}), 0.0, places=2)

        engine, = PFAEngine.fromYaml('''
input: "null"
output: {type: map, values: {type: map, values: double}}
action:
  la.scale:
    - type: {type: map, values: {type: map, values: double}}
      value: {uno: {one: 1, two: 2, three: 3},
              dos: {four: 4, five: 5, six: 6},
              tres: {seven: 7, eight: 8, nine: 9}}
    - 10
''')
        self.assertAlmostEqual(self.chi2(engine.action(None),
                                         {"uno": {"one": 10.0, "two": 20.0, "three": 30.0},
                                          "dos": {"four": 40.0, "five": 50.0, "six": 60.0},
                                          "tres": {"seven": 70.0, "eight": 80.0, "nine": 90.0}}), 0.0, places=2)
Ejemplo n.º 22
0
    def testLogit(self):
        engine, = PFAEngine.fromYaml("""
input: double
output: double
action: {m.link.logit: input}
""")
        self.assertAlmostEqual(engine.action(2.2), 0.9002495108803148, places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: array, items: double}
output: {type: array, items: double}
action: {m.link.logit: input}
""")
        out = engine.action([1, 2, 3, 4])
        self.assertAlmostEqual(out[0], 0.7310585786300049, places = 5)
        self.assertAlmostEqual(out[1], 0.8807970779778823, places = 5)
        self.assertAlmostEqual(out[2], 0.9525741268224334, places = 5)
        self.assertAlmostEqual(out[3], 0.9820137900379085, places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: map, values: double}
output: {type: map, values: double}
action: {m.link.logit: input}
""")
        out = engine.action({"one": 1, "two": 2, "three": 3, "four": 4})
        self.assertAlmostEqual(out["one"],  0.7310585786300049, places = 5)
        self.assertAlmostEqual(out["two"],  0.8807970779778823, places = 5)
        self.assertAlmostEqual(out["three"],0.9525741268224334, places = 5)
        self.assertAlmostEqual(out["four"], 0.9820137900379085, places = 5)
Ejemplo n.º 23
0
    def testProbit(self):
        engine, = PFAEngine.fromYaml("""
input: double
output: double
action: {m.link.probit: input}
""")
        self.assertAlmostEqual(engine.action(2.2), 0.9860965524865013, places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: array, items: double}
output: {type: array, items: double}
action: {m.link.probit: input}
""")
        out = engine.action([1, 2, 3, 4])
        self.assertAlmostEqual(out[0], 0.841344746068543 , places = 5)
        self.assertAlmostEqual(out[1], 0.9772498680518207, places = 5)
        self.assertAlmostEqual(out[2], 0.9986501019683699, places = 5)
        self.assertAlmostEqual(out[3], 0.9999683287581669, places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: map, values: double}
output: {type: map, values: double}
action: {m.link.probit: input}
""")
        out = engine.action({"one": 1, "two": 2, "three": 3, "four": 4})
        self.assertAlmostEqual(out["one"],   0.841344746068543 , places = 5)
        self.assertAlmostEqual(out["two"],   0.9772498680518207, places = 5)
        self.assertAlmostEqual(out["three"], 0.9986501019683699, places = 5)
        self.assertAlmostEqual(out["four"],  0.9999683287581669, places = 5)
Ejemplo n.º 24
0
    def testReLu(self):
        engine, = PFAEngine.fromYaml("""
input: double
output: double
action: {m.link.relu: input}
""")
        self.assertAlmostEqual(engine.action(2.2), 2.2, places = 1)

        engine, = PFAEngine.fromYaml("""
input: {type: array, items: double}
output: {type: array, items: double}
action: {m.link.relu: input}
""")
        out = engine.action([-1, -2, 3, 4])
        self.assertAlmostEqual(out[0], 0.0, places = 5)
        self.assertAlmostEqual(out[1], 0.0, places = 5)
        self.assertAlmostEqual(out[2], 3.0, places = 5)
        self.assertAlmostEqual(out[3], 4.0, places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: map, values: double}
output: {type: map, values: double}
action: {m.link.relu: input}
""")
        out = engine.action({"one": -1, "two": -2, "three": 3, "four": 4})
        self.assertAlmostEqual(out["one"],   0.0, places = 5)
        self.assertAlmostEqual(out["two"],   0.0, places = 5)
        self.assertAlmostEqual(out["three"], 3.0, places = 5)
        self.assertAlmostEqual(out["four"],  4.0, places = 5)
Ejemplo n.º 25
0
    def testtanh(self):
        engine, = PFAEngine.fromYaml("""
input: double
output: double
action: {m.link.tanh: input}
""")
        self.assertAlmostEqual(engine.action(2.2), 0.9757431300314515, places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: array, items: double}
output: {type: array, items: double}
action: {m.link.tanh: input}
""")
        out = engine.action([-1, -2, 3, 4])
        self.assertAlmostEqual(out[0], -0.761594155956, places = 5)
        self.assertAlmostEqual(out[1], -0.964027580076, places = 5)
        self.assertAlmostEqual(out[2], 0.995054753687 , places = 5)
        self.assertAlmostEqual(out[3], 0.999329299739 , places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: map, values: double}
output: {type: map, values: double}
action: {m.link.tanh: input}
""")
        out = engine.action({"one": -1, "two": -2, "three": 3, "four": 4})
        self.assertAlmostEqual(out["one"],   -0.761594155956, places = 5)
        self.assertAlmostEqual(out["two"],   -0.964027580076, places = 5)
        self.assertAlmostEqual(out["three"], 0.995054753687 , places = 5)
        self.assertAlmostEqual(out["four"],  0.999329299739 , places = 5)
Ejemplo n.º 26
0
    def testfindAll(self):
        engine, = PFAEngine.fromYaml("""
input: string
output: {type: array, items: string}
action:
  - {re.findall: [input, [ab]]}
""")
        self.assertEqual(engine.action("abcabcabc"), ["ab","ab", "ab"])
        self.assertEqual(engine.action("88cabcc"),   ["ab"])


# check non-ascii string input
#        engine, = PFAEngine.fromYaml("""
#input: string
#output: {type: array, items: string}
#action:
#  - {re.findall: [input, [猫机+猫]]}
#""")
#        self.assertEqual(engine.action("猫机猫oooo猫机机猫ppp猫机机机猫bbbb猫机aaaa猫机机"), ["猫机猫" ,"猫机机猫","猫机机机猫"])

# check byte input
        engine, = PFAEngine.fromYaml("""
input: bytes
output: {type: array, items: bytes}
action:
  - re.findall: [input, {bytes.encodeUtf8: {string: "ab+"}}]
""")
        self.assertEqual(engine.action("xyz"), [])
        self.assertEqual(engine.action("abc机机abcabc"), ["ab", "ab","ab"] )
Ejemplo n.º 27
0
    def testLoglog(self):
        engine, = PFAEngine.fromYaml("""
input: double
output: double
action: {m.link.loglog: input}
""")
        self.assertAlmostEqual(engine.action(2.2), 1.203611803484212E-4,  places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: array, items: double}
output: {type: array, items: double}
action: {m.link.loglog: input}
""")
        out = engine.action([1, 2, 3, 4])
        self.assertAlmostEqual(out[0], 0.06598803584531254   , places = 5)
        self.assertAlmostEqual(out[1], 6.179789893310934E-4  , places = 5)
        self.assertAlmostEqual(out[2], 1.8921786948382924E-9 , places = 5)
        self.assertAlmostEqual(out[3], 1.9423376049564073E-24, places = 5)

        engine, = PFAEngine.fromYaml("""
input: {type: map, values: double}
output: {type: map, values: double}
action: {m.link.loglog: input}
""")
        out = engine.action({"one": 1, "two": 2, "three": 3, "four": 4})
        self.assertAlmostEqual(out["one"],   0.06598803584531254   , places = 5)
        self.assertAlmostEqual(out["two"],   6.179789893310934E-4  , places = 5)
        self.assertAlmostEqual(out["three"], 1.8921786948382924E-9 , places = 5)
        self.assertAlmostEqual(out["four"],  1.9423376049564073E-24, places = 5)
Ejemplo n.º 28
0
    def testSubMaps(self):
        engine, = PFAEngine.fromYaml('''
input: "null"
output: {type: map, values: double}
action:
  la.sub:
    - type: {type: map, values: double}
      value: {one: 1, two: 2, three: 3, four: 4, five: 5}
    - type: {type: map, values: double}
      value: {one: 101, two: 102, three: 103, four: 104, five: 105, six: 999}
''')
        self.assertAlmostEqual(self.chi2Vector(engine.action(None),
            {"one": -100.0, "two": -100.0, "three": -100.0, "four": -100.0, "five": -100.0, "six": -999.0}), 0.0, places=2)

        engine, = PFAEngine.fromYaml('''
input: "null"
output: {type: map, values: {type: map, values: double}}
action:
  la.sub:
    - type: {type: map, values: {type: map, values: double}}
      value: {uno: {one: 1, two: 2, three: 3},
              dos: {one: 4, two: 5, three: 6},
              tres: {one: 7, two: 8, three: 9}}
    - type: {type: map, values: {type: map, values: double}}
      value: {uno: {one: 101, two: 102, three: 103},
              dos: {one: 104, two: 105, three: 106},
              tres: {one: 107, two: 108, three: 109, four: 999.0}}
''')
        self.assertAlmostEqual(self.chi2(engine.action(None),
                                         {"uno": {"one": -100.0, "two": -100.0, "three": -100.0, "four": 0.0},
                                          "dos": {"one": -100.0, "two": -100.0, "three": -100.0, "four": 0.0},
                                          "tres": {"one": -100.0, "two": -100.0, "three": -100.0, "four": -999.0}}), 0.0, places=2)
Ejemplo n.º 29
0
    def testCartMustBuildNumericalCategorical(self):
        random.seed(12345)
        numpy.seterr(divide="ignore", invalid="ignore")
        dataset = Dataset.fromIterable(((x, y, c) for (x, y, z, a, b, c) in TestProducerCart.data()), 100000, ("x", "y", "c"))

        tree = TreeNode.fromWholeDataset(dataset, "c")
        tree.splitMaxDepth(2)

        doc = tree.pfaDocument({"type": "record", "name": "Datum", "fields": [{"name": "x", "type": "double"}, {"name": "y", "type": "double"}]}, "TreeNode")
        # look(doc, maxDepth=8)

        self.assertEqual(doc["cells"]["tree"]["init"]["field"], "x")
        self.assertAlmostEqual(doc["cells"]["tree"]["init"]["value"], 4.00, places=2)
        self.assertEqual(doc["cells"]["tree"]["init"]["pass"]["TreeNode"]["field"], "y")
        self.assertAlmostEqual(doc["cells"]["tree"]["init"]["pass"]["TreeNode"]["value"], 6.00, places=2)
        self.assertEqual(doc["cells"]["tree"]["init"]["pass"]["TreeNode"]["pass"]["string"], "C3")
        self.assertEqual(doc["cells"]["tree"]["init"]["pass"]["TreeNode"]["fail"]["string"], "C6")
        self.assertEqual(doc["cells"]["tree"]["init"]["fail"]["TreeNode"]["field"], "y")
        self.assertAlmostEqual(doc["cells"]["tree"]["init"]["fail"]["TreeNode"]["value"], 2.00, places=2)
        self.assertEqual(doc["cells"]["tree"]["init"]["fail"]["TreeNode"]["pass"]["string"], "C0")
        self.assertEqual(doc["cells"]["tree"]["init"]["fail"]["TreeNode"]["fail"]["string"], "C0")

        engine, = PFAEngine.fromJson(doc)
        self.assertEqual(engine.action({"x": 2.0, "y": 3.0}), "C3")
        self.assertEqual(engine.action({"x": 2.0, "y": 8.0}), "C6")
        self.assertEqual(engine.action({"x": 7.0, "y": 1.0}), "C0")
        self.assertEqual(engine.action({"x": 7.0, "y": 5.0}), "C0")

        doc = tree.pfaDocument(
            {"type": "record", "name": "Datum", "fields": [{"name": "x", "type": "double"}, {"name": "y", "type": "double"}]},
            "TreeNode",
            nodeScores=True, datasetSize=True, predictandDistribution=True, predictandUnique=True, entropy=True, gain=True)
        # look(doc, maxDepth=8)
        engine, = PFAEngine.fromJson(doc)
Ejemplo n.º 30
0
        def bad():
            PFAEngine.fromYaml('''
input: ["null", "null"]
output: "null"
action:
  - {impute.defaultOnNull: [input, "null"]}
''')
Ejemplo n.º 31
0
    def testAdditionIntOverflows(self):
        engine, = PFAEngine.fromYaml('''
input: int
output: int
action:
  - {+: [input, 10]}
''')
        self.assertEqual(engine.action(2147483637), 2147483647)
        self.assertRaises(PFARuntimeException,
                          lambda: engine.action(2147483638))

        engine, = PFAEngine.fromYaml('''
input: int
output: int
action:
  - {+: [input, -10]}
''')
        self.assertEqual(engine.action(-2147483638), -2147483648)
        self.assertRaises(PFARuntimeException,
                          lambda: engine.action(-2147483639))
Ejemplo n.º 32
0
    def testSqrt(self):
        engine, = PFAEngine.fromYaml('''
input: double
output: double
action:
  - {m.sqrt: input}
''')
        self.assertEqual(str(engine.action(-1)), "nan")
        self.assertAlmostEqual(engine.action(0), 0.00, places=2)
        self.assertAlmostEqual(engine.action(0.5), 0.71, places=2)
        self.assertAlmostEqual(engine.action(22.5), 4.74, places=2)
Ejemplo n.º 33
0
    def testProvideConstants(self):
        engine, = PFAEngine.fromYaml('''
input: "null"
output: double
action:
  - {m.pi: []}
''')
        self.assertAlmostEqual(engine.action(None),
                               3.141592653589793,
                               places=14)

        engine, = PFAEngine.fromYaml('''
input: "null"
output: double
action:
  - {m.e: []}
''')
        self.assertAlmostEqual(engine.action(None),
                               2.718281828459045,
                               places=14)
Ejemplo n.º 34
0
    def testSimpleTree(self):
        engine, = PFAEngine.fromPmml('''
<PMML version="4.2">
    <Header copyright=""/>
    <DataDictionary>
        <DataField name="x" optype="continuous" dataType="double" />
        <DataField name="y" optype="continuous" dataType="integer" />
        <DataField name="z" optype="categorical" dataType="string" />
    </DataDictionary>
    <TreeModel functionName="categorical" splitCharacteristic="binarySplit">
        <Node>
            <True/>
            <Node>
                <SimplePredicate field="x" operator="lessThan" value="1"/>
                <Node score="leaf-1">
                    <SimplePredicate field="z" operator="equal" value="hello"/>
                </Node>
                <Node score="leaf-2">
                    <SimplePredicate field="z" operator="notEqual" value="hello"/>
                </Node>
            </Node>
            <Node>
                <SimplePredicate field="x" operator="greaterOrEqual" value="1"/>
                <Node score="leaf-3">
                    <SimplePredicate field="z" operator="equal" value="hello"/>
                </Node>
                <Node score="leaf-4">
                    <SimplePredicate field="z" operator="notEqual" value="hello"/>
                </Node>
            </Node>
        </Node>
    </TreeModel>
</PMML>
''')
        self.assertEqual(engine.action({
            "x": 0.9,
            "y": 0,
            "z": "hello"
        }), "leaf-1")
        self.assertEqual(engine.action({
            "x": 0.9,
            "y": 0,
            "z": "goodbye"
        }), "leaf-2")
        self.assertEqual(engine.action({
            "x": 1.1,
            "y": 0,
            "z": "hello"
        }), "leaf-3")
        self.assertEqual(engine.action({
            "x": 1.1,
            "y": 0,
            "z": "goodbye"
        }), "leaf-4")
Ejemplo n.º 35
0
    def testDoReplaceAll(self):
        engine, = PFAEngine.fromYaml('''
input: string
output: string
action:
  - {s.replaceall: [input, [ey], [EY]]}
''')
        self.assertEqual(engine.action("hey"), "hEY")
        self.assertEqual(engine.action("hey hey hey"), "hEY hEY hEY")
        self.assertEqual(engine.action("abc"), "abc")
        self.assertEqual(engine.action("yeh yeh yeh"), "yeh yeh yeh")
Ejemplo n.º 36
0
    def testDoIndex(self):
        engine, = PFAEngine.fromYaml('''
input: string
output: int
action:
  - {s.index: [input, [ack!]]}
''')
        self.assertEqual(engine.action("ABCDEFGHIJKLMNOPQRSTUVWXYZ"), -1)
        self.assertEqual(engine.action("ack! ack! ack!"), 0)
        self.assertEqual(engine.action("adfasdfadfack!asdfasdf ackasdfadfd! ack!asdfadsf"), 10)
        self.assertEqual(engine.action("adfasdfadack!asdfasdfasdf"), 9)
Ejemplo n.º 37
0
    def testDoEndswith(self):
        engine, = PFAEngine.fromYaml('''
input: string
output: boolean
action:
  - {s.endswith: [input, [ack!]]}
''')
        self.assertFalse(engine.action("ABCDEFGHIJKLMNOPQRSTUVWXYZ"))
        self.assertTrue(engine.action("ack! ack! ack!"))
        self.assertTrue(engine.action("adfasdfadfack!asdfasdf ackasdfadfd! ack!asdfadsfack!"))
        self.assertFalse(engine.action("adfasdfadack!asdfasdfasdf"))
Ejemplo n.º 38
0
    def testLong(self):
        engine1, = PFAEngine.fromYaml('''
input: "null"
output: long
randseed: 12345
action: {rand.long: []}
''')
        self.assertEqual(engine1.action(None), 4292285838037326215)
        self.assertEqual(engine1.action(None), 6551146165133617474)
        self.assertEqual(engine1.action(None), -5650950641291792112)

        engine2, = PFAEngine.fromYaml('''
input: "null"
output: long
randseed: 12345
action: {rand.long: [5, 10]}
''')
        self.assertEqual(engine2.action(None), 7)
        self.assertEqual(engine2.action(None), 5)
        self.assertEqual(engine2.action(None), 9)
Ejemplo n.º 39
0
    def testHandleSubtractionIntOverflows(self):
        engine, = PFAEngine.fromYaml('''
input: int
output: int
action:
  - {-: [-10, input]}
''')
        self.assertEqual(engine.action(2147483638), -2147483648)
        self.assertRaises(PFARuntimeException,
                          lambda: engine.action(2147483639))

        engine, = PFAEngine.fromYaml('''
input: int
output: int
action:
  - {-: [10, input]}
''')
        self.assertEqual(engine.action(-2147483637), 2147483647)
        self.assertRaises(PFARuntimeException,
                          lambda: engine.action(-2147483638))
Ejemplo n.º 40
0
    def testIsNan(self):
        floatEngine, = PFAEngine.fromYaml('''
input: float
output: boolean
action: {impute.isnan: input}
''')
        self.assertFalse(floatEngine.action(123.4))
        self.assertTrue(floatEngine.action(float("nan")))
        self.assertFalse(floatEngine.action(float("inf")))
        self.assertFalse(floatEngine.action(float("-inf")))

        doubleEngine, = PFAEngine.fromYaml('''
input: double
output: boolean
action: {impute.isnan: input}
''')
        self.assertFalse(doubleEngine.action(123.4))
        self.assertTrue(doubleEngine.action(float("nan")))
        self.assertFalse(doubleEngine.action(float("inf")))
        self.assertFalse(doubleEngine.action(float("-inf")))
Ejemplo n.º 41
0
    def testHandleNegativeLongOverflows(self):
        engine, = PFAEngine.fromYaml('''
input: long
output: long
action:
  - {u-: [input]}
''')
        self.assertEqual(engine.action(9223372036854775807),
                         -9223372036854775807)
        self.assertRaises(PFARuntimeException,
                          lambda: engine.action(-9223372036854775808))
Ejemplo n.º 42
0
    def testDefaultOnNonNum(self):
        floatEngine, = PFAEngine.fromYaml('''
input: float
output: float
action: {impute.defaultOnNonNum: [input, {float: 999.0}]}
''')
        self.assertEqual(floatEngine.action(123.4), 123.4)
        self.assertEqual(floatEngine.action(float("nan")), 999.0)
        self.assertEqual(floatEngine.action(float("inf")), 999.0)
        self.assertEqual(floatEngine.action(float("-inf")), 999.0)

        doubleEngine, = PFAEngine.fromYaml('''
input: double
output: double
action: {impute.defaultOnNonNum: [input, 999.0]}
''')
        self.assertEqual(doubleEngine.action(123.4), 123.4)
        self.assertEqual(doubleEngine.action(float("nan")), 999.0)
        self.assertEqual(doubleEngine.action(float("inf")), 999.0)
        self.assertEqual(doubleEngine.action(float("-inf")), 999.0)
Ejemplo n.º 43
0
    def testInt(self):
        engine1, = PFAEngine.fromYaml('''
input: "null"
output: int
randseed: 12345
action: {rand.int: []}
''')
        self.assertEqual(engine1.action(None), -358114921)
        self.assertEqual(engine1.action(None), -2103807398)
        self.assertEqual(engine1.action(None), 1396751321)

        engine2, = PFAEngine.fromYaml('''
input: "null"
output: int
randseed: 12345
action: {rand.int: [5, 10]}
''')
        self.assertEqual(engine2.action(None), 7)
        self.assertEqual(engine2.action(None), 5)
        self.assertEqual(engine2.action(None), 9)
Ejemplo n.º 44
0
    def testEncodeAscii(self):
        engine, = PFAEngine.fromYaml('''
input: string
output: bytes
action:
  bytes.encodeAscii: input
''')
        self.assertEqual(engine.action("hello"),
                         struct.pack("bbbbb", 104, 101, 108, 108, 111))
        self.assertRaises(PFARuntimeException,
                          lambda: engine.action("hel\x81o"))
Ejemplo n.º 45
0
    def testErrorOnNull(self):
        engine, = PFAEngine.fromYaml('''
input: [int, "null"]
output: int
action:
  - {impute.errorOnNull: [input]}
''')
        self.assertEqual(engine.action(3), 3)
        self.assertEqual(engine.action(12), 12)
        self.assertRaises(PFARuntimeException, lambda: engine.action(None))
        self.assertEqual(engine.action(5), 5)
Ejemplo n.º 46
0
    def testCheckUtf16le(self):
        engine, = PFAEngine.fromYaml('''
input: bytes
output: boolean
action:
  bytes.isUtf16le: input
''')
        self.assertEqual(
            engine.action(
                struct.pack("bbbbbbbbbb", 104, 0, 101, 0, 108, 0, 108, 0, 111,
                            0)), True)
Ejemplo n.º 47
0
    def testEncodeUtf16(self):
        engine, = PFAEngine.fromYaml('''
input: string
output: bytes
action:
  bytes.encodeUtf16: input
''')
        self.assertEqual(
            engine.action("hello"),
            struct.pack("bbbbbbbbbbbb", -1, -2, 104, 0, 101, 0, 108, 0, 108, 0,
                        111, 0))
Ejemplo n.º 48
0
    def testIn(self):
        engine, = PFAEngine.fromYaml('''
input: int
output: boolean
action:
  map.in:
    - {map.toset: {value: [1, 2, 3, 4, 5], type: {type: array, items: int}}}
    - input
''')
        self.assertTrue(engine.action(2))
        self.assertFalse(engine.action(0))
Ejemplo n.º 49
0
    def testDecodeUtf16le(self):
        engine, = PFAEngine.fromYaml('''
input: bytes
output: string
action:
  bytes.decodeUtf16le: input
''')
        self.assertEqual(
            engine.action(
                struct.pack("bbbbbbbbbb", 104, 0, 101, 0, 108, 0, 108, 0, 111,
                            0)), "hello")
Ejemplo n.º 50
0
    def testDecodeLatin1(self):
        engine, = PFAEngine.fromYaml('''
input: bytes
output: string
action:
  bytes.decodeLatin1: input
''')
        self.assertEqual(
            engine.action(struct.pack("bbbbb", 104, 101, 108, 108, 111)),
            "hello")
        self.assertEqual(engine.action('hello'), "hello")
Ejemplo n.º 51
0
    def testSymDiff(self):
        engine, = PFAEngine.fromYaml('''
input: "null"
output: {type: array, items: int}
action:
  map.fromset:
    map.symdiff:
      - {map.toset: {value: [1, 2, 3, 4, 5], type: {type: array, items: int}}}
      - {map.toset: {value: [4, 5, 6, 7, 8], type: {type: array, items: int}}}
''')
        self.assertEqual(set(engine.action(None)), set([1, 2, 3, 6, 7, 8]))
Ejemplo n.º 52
0
    def testToString(self):
        engine, = PFAEngine.fromYaml('''
input: {type: enum, name: Test, symbols: ["A", "B", "C"]}
output: string
action:
  enum.toString: input
''')
        self.assertEqual(engine.action("A"), "A")
        self.assertEqual(engine.action("B"), "B")
        self.assertEqual(engine.action("C"), "C")
        self.assertRaises(AvroException, lambda: engine.action("D"))
Ejemplo n.º 53
0
    def testSignum(self):
        engine, = PFAEngine.fromYaml('''
input: double
output: double
action:
  - {m.signum: input}
''')
        self.assertEqual(engine.action(-3.2), -1)
        self.assertEqual(engine.action(0), 0)
        self.assertEqual(engine.action(3.2), 1)
        self.assertEqual(engine.action(1.0), 1)
Ejemplo n.º 54
0
    def testrIndex(self):
        engine, = PFAEngine.fromYaml("""
input: string
output: {type: array, items: int}
action:
  - {re.rindex: [input, [ab(c|d)*]]}
""")
        self.assertEqual(engine.action("abcccdc"), [0,7])
        self.assertEqual(engine.action("abddddd"), [0,7])
        self.assertEqual(engine.action("XKASGJ8"), [])

        engine, = PFAEngine.fromYaml("""
input: string
output: {type: array, items: int}
action:
  - {re.rindex: [input, [dog]]}
""")
        self.assertEqual(engine.action("999dogggggg"),  [3,6])
        self.assertEqual(engine.action("cat"),          [])
        self.assertEqual(engine.action("catdogpppdog"), [9,12])


# check non-ascii string input
#        engine, = PFAEngine.fromYaml("""
#input: string
#output: {type: array, items: int}
#action:
#  - {re.rindex: [input, [对讲机(讲|机)*]]}
#""")
#        self.assertEqual(engine.action("abcccdc"), [])
#        self.assertEqual(engine.action("xyzzzz对讲机机abcc对讲机机mmmmm对讲机机aa"), [23,27])

# check byte input
        engine, = PFAEngine.fromYaml("""
input: bytes
output: {type: array, items: int}
action:
  - re.rindex: [input, {bytes.encodeUtf8: {string: "对讲机(讲|机)*"}}]
""")
        self.assertEqual(engine.action("abcccdc"), [])
        self.assertEqual(engine.action("xyzzzz对讲机机abcc对讲机机mmmmm对讲机机aa"), [39,51])
Ejemplo n.º 55
0
    def testHistogram2(self):
        engine, = PFAEngine.fromYaml('''
input: "null"
output: HistogramItem
randseed: 12345
cells:
  hist:
    type:
      type: array
      items:
        type: record
        name: HistogramItem
        fields:
          - {name: label, type: string}
          - {name: prob, type: double}
    init:
      - {label: A, prob: 3.3}
      - {label: B, prob: 2.2}
      - {label: C, prob: 5.5}
      - {label: D, prob: 0.0}
      - {label: E, prob: 1.1}
      - {label: F, prob: 8.8}
action: {rand.histogram: {cell: hist}}
''')
        results = [engine.action(None) for i in range(0, 10000)]
        self.assertAlmostEqual(sum(1 for x in results if x["label"] == "A") /
                               10000.0,
                               0.15789473684210525,
                               places=2)
        self.assertAlmostEqual(sum(1 for x in results if x["label"] == "B") /
                               10000.0,
                               0.10526315789473686,
                               places=2)
        self.assertAlmostEqual(sum(1 for x in results if x["label"] == "C") /
                               10000.0,
                               0.26315789473684215,
                               places=2)
        self.assertAlmostEqual(sum(1 for x in results if x["label"] == "D") /
                               10000.0,
                               0.0,
                               places=2)
        self.assertAlmostEqual(sum(1 for x in results if x["label"] == "E") /
                               10000.0,
                               0.05263157894736843,
                               places=2)
        self.assertAlmostEqual(sum(1 for x in results if x["label"] == "F") /
                               10000.0,
                               0.42105263157894746,
                               places=2)
        self.assertAlmostEqual(sum(1 for x in results if x["label"] == "G") /
                               10000.0,
                               0.0,
                               places=2)
Ejemplo n.º 56
0
    def testErfcFcn(self):
        engine, = PFAEngine.fromYaml('''
input: double
output: double
action:
  - {m.special.erfc: input}
''')
        self.assertAlmostEqual(engine.action(-22.5), 2.00, places=3)
        self.assertAlmostEqual(engine.action(-0.5), 1.52, places=3)
        self.assertAlmostEqual(engine.action(0), 1.00, places=3)
        self.assertAlmostEqual(engine.action(0.5), 0.4795, places=3)
        self.assertAlmostEqual(engine.action(22.5), 0.00, places=3)
Ejemplo n.º 57
0
    def testDoUpper(self):
        engine, = PFAEngine.fromYaml('''
input: string
output: string
action:
  - {s.upper: [input]}
''')
        self.assertEqual(engine.action("hey"), "HEY")
        self.assertEqual(engine.action("Hey"), "HEY")
        self.assertEqual(engine.action("HEY"), "HEY")
        self.assertEqual(engine.action("hEy"), "HEY")
        self.assertEqual(engine.action("heY"), "HEY")
Ejemplo n.º 58
0
    def testAccumulateACovarianceAndUseThatToUpdateAPCAMatrixUsingArrays(self):
        engine, = PFAEngine.fromYaml('''
input: {type: array, items: double}
output: {type: array, items: double}
cells:
  state:
    type:
      type: record
      name: State
      fields:
        - {name: count, type: double}
        - {name: mean, type: {type: array, items: double}}
        - {name: covariance, type: {type: array, items: {type: array, items: double}}}
    init:
      count: 0
      mean: [0, 0, 0, 0, 0]
      covariance: [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
action:
  - let:
      mat:
        la.truncate:
          - la.eigenBasis:
              - attr:
                  cell: state
                  to:
                    params: [{state: State}]
                    ret: State
                    do:
                      stat.sample.updateCovariance:
                        - input
                        - 1.0
                        - state
                path: [[covariance]]
          - 2
  - let:
      vec:
        a.mapWithIndex:
          - input
          - params: [{i: int}, {x: double}]
            ret: double
            do: {"-": [x, {cell: state, path: [[mean], i]}]}
  - if: {">=": [{cell: state, path: [[count]]}, 2]}
    then: {la.dot: [mat, vec]}
    else: {type: {type: array, items: double}, value: []}
''')
        engine.action([23, 56, 12, 34, 72])
        engine.action([52, 61, 12, 71, 91])
        engine.action([15, 12, 89, 23, 48])

        self.assertAlmostEqual(self.chi2Vector(
            engine.action([16, 27, 36, 84, 52]), [-0.038, -1.601]),
                               0.0,
                               places=2)
Ejemplo n.º 59
0
    def testHourOfDay(self):
        engine, = PFAEngine.fromYaml("""
input: double
output: int
action:
  - {time.hourOfDay: [input, {string: ""}]}
""")
        self.assertEqual(engine.action(0), 0)
        self.assertEqual(engine.action(1425508527), 22)
        self.assertEqual(engine.action(1.425508527E9), 22)
        self.assertEqual(engine.action(1425508527.52482), 22)

        engine2, = PFAEngine.fromYaml("""
input: string
output: int
action:
  - {time.hourOfDay: [0, input]}
""")
        self.assertEqual(engine2.action("Europe/Paris"), 1)
        self.assertEqual(engine2.action("Etc/UTC"), 0)
        self.assertEqual(engine2.action("Atlantic/Azores"), 23)
Ejemplo n.º 60
0
    def testDisjoint(self):
        engine, = PFAEngine.fromYaml('''
input: {type: array, items: int}
output: boolean
action:
  map.disjoint:
    - {map.toset: input}
    - {map.toset: {value: [1, 2, 3, 4, 5], type: {type: array, items: int}}}
''')
        self.assertFalse(engine.action([1, 2, 3]))
        self.assertFalse(engine.action([1, 2, 3, 999]))
        self.assertTrue(engine.action([888, 999]))