Beispiel #1
0
	def testKeyTerm(self):
		# the testData is bits and pieces of several actual entries to create a complete test
		# case
		testData = []
		testData.append('\\key Abba')
		testData.append('\\optional <table class="opt">' + \
						'<tr><td>Greek Term</td><td>Strong</td><td>Louw.Nida</td><td>Gloss</td></tr>' + \
						'<tr><td><font face="SIL Greek Trans">abba            </font></td><td>5     </td><td>12.12      </td><td>Father, transliterated from Aramaic</td></tr>' + \
						'<tr><td><font face="SIL Greek Trans"/></td><td/><td>35.16       </td><td>helper</td></tr>' + \
						'<tr><td colspan="4">See also MEDIATOR.</td></tr>' + \
						'</table><p>description of term</p>')
		testData.append('\\ref MRK 14:36')
		testData.append('\\rfnote Greek: <font face="SIL Greek Trans">abba</font>text of comment')
		testData.append('\\key1 Advocate')
		testData.append('\\keynote1  Advocate, one who speaks on behalf of another')
		testData.append('\\ref MAT 9:18')
		testData.append('\\rfnote Greek: <font face="SIL Greek Trans">archwn</font>')


		testOutput = TestOutput()
		ConvertFile.processKeyTerms(testData, testOutput)

		# print testOutput.output
		self.assertEqual('<keyterm name="Abba">',
						 testOutput.Next())
		self.assertEqual('<original_term term="abba" Strong="5" Louw.Nida="12.12" gloss="Father, transliterated from Aramaic" />',
						 testOutput.Next())
		self.assertEqual('<original_term term="abba" Strong="" Louw.Nida="35.16" gloss="helper" />',
						 testOutput.Next())
		self.assertEqual('<original_term term="" Strong="" Louw.Nida="" gloss="See also MEDIATOR." />',
						 testOutput.Next())
		self.assertEqual('<description>description of term</description>',
						 testOutput.Next())
		self.assertEqual('<ref location="MRK 14:36">',
						 testOutput.Next())
		self.assertEqual('<keyword>abba</keyword>',
						 testOutput.Next())
		self.assertEqual('<comment>text of comment</comment>',
						 testOutput.Next())
		self.assertEqual('</ref>',
						 testOutput.Next())
		self.assertEqual('<sense name="Advocate, one who speaks on behalf of another">',
						 testOutput.Next())
		self.assertEqual('<ref location="MAT 9:18">',
						 testOutput.Next())
		self.assertEqual('<keyword>archwn</keyword>',
						 testOutput.Next())
		self.assertEqual('</ref>',
						 testOutput.Next())
		self.assertEqual('</sense>',
						 testOutput.Next())
		self.assertEqual('</keyterm>',
						 testOutput.Next())
		self.assertEqual(None, testOutput.Next())
Beispiel #2
0
    def testKeyTerm(self):
        # the testData is bits and pieces of several actual entries to create a complete test
        # case
        testData = []
        testData.append('\\key Abba')
        testData.append('\\optional <table class="opt">' + \
            '<tr><td>Greek Term</td><td>Strong</td><td>Louw.Nida</td><td>Gloss</td></tr>' + \
            '<tr><td><font face="SIL Greek Trans">abba            </font></td><td>5     </td><td>12.12      </td><td>Father, transliterated from Aramaic</td></tr>' + \
            '<tr><td><font face="SIL Greek Trans"/></td><td/><td>35.16       </td><td>helper</td></tr>' + \
            '<tr><td colspan="4">See also MEDIATOR.</td></tr>' + \
            '</table><p>description of term</p>')
        testData.append('\\ref MRK 14:36')
        testData.append(
            '\\rfnote Greek: <font face="SIL Greek Trans">abba</font>text of comment'
        )
        testData.append('\\key1 Advocate')
        testData.append(
            '\\keynote1  Advocate, one who speaks on behalf of another')
        testData.append('\\ref MAT 9:18')
        testData.append(
            '\\rfnote Greek: <font face="SIL Greek Trans">archwn</font>')

        testOutput = TestOutput()
        ConvertFile.processKeyTerms(testData, testOutput)

        # print testOutput.output
        self.assertEqual('<keyterm name="Abba">', testOutput.Next())
        self.assertEqual(
            '<original_term term="abba" Strong="5" Louw.Nida="12.12" gloss="Father, transliterated from Aramaic" />',
            testOutput.Next())
        self.assertEqual(
            '<original_term term="abba" Strong="" Louw.Nida="35.16" gloss="helper" />',
            testOutput.Next())
        self.assertEqual(
            '<original_term term="" Strong="" Louw.Nida="" gloss="See also MEDIATOR." />',
            testOutput.Next())
        self.assertEqual('<description>description of term</description>',
                         testOutput.Next())
        self.assertEqual('<ref location="MRK 14:36">', testOutput.Next())
        self.assertEqual('<keyword>abba</keyword>', testOutput.Next())
        self.assertEqual('<comment>text of comment</comment>',
                         testOutput.Next())
        self.assertEqual('</ref>', testOutput.Next())
        self.assertEqual(
            '<sense name="Advocate, one who speaks on behalf of another">',
            testOutput.Next())
        self.assertEqual('<ref location="MAT 9:18">', testOutput.Next())
        self.assertEqual('<keyword>archwn</keyword>', testOutput.Next())
        self.assertEqual('</ref>', testOutput.Next())
        self.assertEqual('</sense>', testOutput.Next())
        self.assertEqual('</keyterm>', testOutput.Next())
        self.assertEqual(None, testOutput.Next())
Beispiel #3
0
    def testKeyTermReference(self):
        testData = []
        testData.append('\\key Abstinence from eating (see Fast)')

        testOutput = TestOutput()
        ConvertFile.processKeyTerms(testData, testOutput)

        # print testOutput.output
        self.assertEqual('<keyterm name="Abstinence_from_eating">',
                         testOutput.Next())
        self.assertEqual('<cross_reference key="Fast" />', testOutput.Next())
        self.assertEqual('</keyterm>', testOutput.Next())
        self.assertEqual(None, testOutput.Next())
Beispiel #4
0
	def testKeyTermReference(self):
		testData = []
		testData.append('\\key Abstinence from eating (see Fast)')

		testOutput = TestOutput()
		ConvertFile.processKeyTerms(testData, testOutput)

		# print testOutput.output
		self.assertEqual('<keyterm name="Abstinence_from_eating">',
						 testOutput.Next())
		self.assertEqual('<cross_reference key="Fast" />',
						 testOutput.Next())
		self.assertEqual('</keyterm>',
						 testOutput.Next())
		self.assertEqual(None, testOutput.Next())
Beispiel #5
0
	def testNestedSensesThreeDeep(self):
		# the testData is bits and pieces of several actual entries to create a complete test
		# case
		testData = []
		testData.append('\\key Abba')
		testData.append('\\optional <table class="opt">' + \
						'<tr><td>Greek Term</td><td>Strong</td><td>Louw.Nida</td><td>Gloss</td></tr>' + \
						'<tr><td><font face="SIL Greek Trans">abba            </font></td><td>5     </td><td>12.12      </td><td>Father, transliterated from Aramaic</td></tr>' + \
						'</table>')
		testData.append('\\key1 Advocate')
		testData.append('\\keynote1  Advocate, one who speaks on behalf of another')
		testData.append('\\key2 Adultery')
		testData.append('\\keynote2  Masculine offenders')
		testData.append('\\key3 Believe')
		testData.append('\\keynote3  To believe that a statement is true')
		testData.append('\\ref MAT 8:13')
		testData.append('\\rfnote Greek: <font face="SIL Greek Trans">pisteuw (verb)</font>')


		testOutput = TestOutput()
		ConvertFile.processKeyTerms(testData, testOutput)

		# print testOutput.output
		self.assertEqual('<keyterm name="Abba">',
						 testOutput.Next())
		self.assertEqual('<original_term term="abba" Strong="5" Louw.Nida="12.12" gloss="Father, transliterated from Aramaic" />',
						 testOutput.Next())
		self.assertEqual('<sense name="Advocate, one who speaks on behalf of another">',
						 testOutput.Next())
		self.assertEqual('<sense name="Masculine offenders">',
						 testOutput.Next())
		self.assertEqual('<sense name="To believe that a statement is true">',
						 testOutput.Next())
		self.assertEqual('<ref location="MAT 8:13">',
						 testOutput.Next())
		self.assertEqual('<keyword>pisteuw (verb)</keyword>',
						 testOutput.Next())
		self.assertEqual('</ref>',
						 testOutput.Next())
		self.assertEqual('</sense>',
						 testOutput.Next())
		self.assertEqual('</sense>',
						 testOutput.Next())
		self.assertEqual('</sense>',
						 testOutput.Next())
		self.assertEqual('</keyterm>',
						 testOutput.Next())
		self.assertEqual(None, testOutput.Next())
def studentRR():
    output = cf.getStudent()
    #privacy parameter
    p = .1
    Xstudent = rr.RandomizedResponse(p, output)
    distance = rr.RecoverDistanceRR(p,Xstudent)
    return distance
Beispiel #7
0
def studentRR():
    output = cf.getStudent()
    #privacy parameter
    p = .1
    Xstudent = rr.RandomizedResponse(p, output)
    distance = rr.RecoverDistanceRR(p, Xstudent)
    return distance
def printResults():
    print ("******************************************************************************")
    print ("******************************  RANDOMIZED RESPONSE  *************************")
    print ("******************************************************************************\n")


    print("INPUT RANDOMIZED RESPONSE + HEART TEXT: \n\n {} \n".format(cf.getHeart()))
    output1 = rr.RandomizedResponse(0.4,cf.getHeart())
    print("OUTPUT RANDOMIZED RESPONSE + HEART TEXT: \n\n {} \n".format(output1))

    print("INPUT RANDOMIZED RESPONSE + STUDENT TEXT: \n\n {} \n".format(cf.getStudent()))
    output2 = rr.RandomizedResponse(0.4,cf.getStudent())
    print("OUTPUT RANDOMIZED RESPONSE + STUDENT TEXT: \n\n {} \n".format(output2))



    print ("******************************************************************************")
    print ("******************************   PRIVATE PROTECTION   *************************")
    print ("******************************************************************************\n")

    print("INPUT PRIVATE PROTECTION + HEART TEXT: \n\n {} \n".format(cf.getHeart()))
    Zheart, Pheart, sigma = pp.PrivateProtection(cf.getHeart())
    print("OUTPUT PRIVATE PROTECTION Z + HEART TEXT: \n\n {} \n".format(Zheart))
    print("OUTPUT PRIVATE PROTECTION P + HEART TEXT: \n\n {} \n".format(Pheart))


    print("INPUT PRIVATE PROTECTION + STUDENT TEXT: \n\n {} \n".format(cf.getStudent()))
    Zstudent, Pstudent, sigma = pp.PrivateProtection(cf.getStudent())
    print("OUTPUT PRIVATE PROTECTION Z + STUDENT TEXT: \n\n {} \n".format(Zstudent))
    print("OUTPUT PRIVATE PROTECTION P + STUDENT TEXT: \n\n {} \n".format(Pstudent))


    print ("*********************************************************************")
    print ("******************************   RECOVERED DISTANCE   *************************")
    print ("*********************************************************************\n")

    print("INPUT PRIVATE PROTECTION + HEART TEXT: \n\n {} \n".format(cf.getHeart()))
    Zheart, Pheart, sigma = pp.PrivateProtection(cf.getHeart())
    print("OUTPUT PRIVATE PROTECTION Z + HEART TEXT: \n\n {} \n".format(Zheart))
    distance = pp.recoveredDistance(Zheart,sigma)


    print(distance[0])
    print(distance[1])
    print(distance[2])
Beispiel #9
0
    def testNestedSensesThreeDeep(self):
        # the testData is bits and pieces of several actual entries to create a complete test
        # case
        testData = []
        testData.append('\\key Abba')
        testData.append('\\optional <table class="opt">' + \
            '<tr><td>Greek Term</td><td>Strong</td><td>Louw.Nida</td><td>Gloss</td></tr>' + \
            '<tr><td><font face="SIL Greek Trans">abba            </font></td><td>5     </td><td>12.12      </td><td>Father, transliterated from Aramaic</td></tr>' + \
            '</table>')
        testData.append('\\key1 Advocate')
        testData.append(
            '\\keynote1  Advocate, one who speaks on behalf of another')
        testData.append('\\key2 Adultery')
        testData.append('\\keynote2  Masculine offenders')
        testData.append('\\key3 Believe')
        testData.append('\\keynote3  To believe that a statement is true')
        testData.append('\\ref MAT 8:13')
        testData.append(
            '\\rfnote Greek: <font face="SIL Greek Trans">pisteuw (verb)</font>'
        )

        testOutput = TestOutput()
        ConvertFile.processKeyTerms(testData, testOutput)

        # print testOutput.output
        self.assertEqual('<keyterm name="Abba">', testOutput.Next())
        self.assertEqual(
            '<original_term term="abba" Strong="5" Louw.Nida="12.12" gloss="Father, transliterated from Aramaic" />',
            testOutput.Next())
        self.assertEqual(
            '<sense name="Advocate, one who speaks on behalf of another">',
            testOutput.Next())
        self.assertEqual('<sense name="Masculine offenders">',
                         testOutput.Next())
        self.assertEqual('<sense name="To believe that a statement is true">',
                         testOutput.Next())
        self.assertEqual('<ref location="MAT 8:13">', testOutput.Next())
        self.assertEqual('<keyword>pisteuw (verb)</keyword>',
                         testOutput.Next())
        self.assertEqual('</ref>', testOutput.Next())
        self.assertEqual('</sense>', testOutput.Next())
        self.assertEqual('</sense>', testOutput.Next())
        self.assertEqual('</sense>', testOutput.Next())
        self.assertEqual('</keyterm>', testOutput.Next())
        self.assertEqual(None, testOutput.Next())
def studentMatrix():
    matrix = cf.getStudent()
    (n,d) = matrix.shape
    dist = []
    for i in range(0,n):
        row = []
        for j in range(0, n):
            if (i == j):
                row.append(0)
            else:
                #row.append("{} compared with {}".format(i,j))
                userA = matrix[i]
                userB = matrix[j]
                euc = distance.euclidean(userA, userB)**2
                #tmp = (euc - (2*k*p)*(1-p))/((1-2*p)**2)
                row.append(euc)
        dist.append(row)
    return np.array(dist)
    #dist = distance.squareform(distance.pdist(matrix, metric='euclidean'))
    dist
    return dist
Beispiel #11
0
def studentMatrix():
    matrix = cf.getStudent()
    (n, d) = matrix.shape
    dist = []
    for i in range(0, n):
        row = []
        for j in range(0, n):
            if (i == j):
                row.append(0)
            else:
                #row.append("{} compared with {}".format(i,j))
                userA = matrix[i]
                userB = matrix[j]
                euc = distance.euclidean(userA, userB)**2
                #tmp = (euc - (2*k*p)*(1-p))/((1-2*p)**2)
                row.append(euc)
        dist.append(row)
    return np.array(dist)
    #dist = distance.squareform(distance.pdist(matrix, metric='euclidean'))
    dist
    return dist
Beispiel #12
0
def heartMatrix():
    matrix = cf.getHeart()
    dist = distance.squareform(distance.pdist(matrix, metric='euclidean'))
    return dist
Beispiel #13
0
def printResults():
    print(
        "******************************************************************************"
    )
    print(
        "******************************  RANDOMIZED RESPONSE  *************************"
    )
    print(
        "******************************************************************************\n"
    )

    print("INPUT RANDOMIZED RESPONSE + HEART TEXT: \n\n {} \n".format(
        cf.getHeart()))
    output1 = rr.RandomizedResponse(0.4, cf.getHeart())
    print(
        "OUTPUT RANDOMIZED RESPONSE + HEART TEXT: \n\n {} \n".format(output1))

    print("INPUT RANDOMIZED RESPONSE + STUDENT TEXT: \n\n {} \n".format(
        cf.getStudent()))
    output2 = rr.RandomizedResponse(0.4, cf.getStudent())
    print("OUTPUT RANDOMIZED RESPONSE + STUDENT TEXT: \n\n {} \n".format(
        output2))

    print(
        "******************************************************************************"
    )
    print(
        "******************************   PRIVATE PROTECTION   *************************"
    )
    print(
        "******************************************************************************\n"
    )

    print("INPUT PRIVATE PROTECTION + HEART TEXT: \n\n {} \n".format(
        cf.getHeart()))
    Zheart, Pheart, sigma = pp.PrivateProtection(cf.getHeart())
    print(
        "OUTPUT PRIVATE PROTECTION Z + HEART TEXT: \n\n {} \n".format(Zheart))
    print(
        "OUTPUT PRIVATE PROTECTION P + HEART TEXT: \n\n {} \n".format(Pheart))

    print("INPUT PRIVATE PROTECTION + STUDENT TEXT: \n\n {} \n".format(
        cf.getStudent()))
    Zstudent, Pstudent, sigma = pp.PrivateProtection(cf.getStudent())
    print("OUTPUT PRIVATE PROTECTION Z + STUDENT TEXT: \n\n {} \n".format(
        Zstudent))
    print("OUTPUT PRIVATE PROTECTION P + STUDENT TEXT: \n\n {} \n".format(
        Pstudent))

    print(
        "*********************************************************************"
    )
    print(
        "******************************   RECOVERED DISTANCE   *************************"
    )
    print(
        "*********************************************************************\n"
    )

    print("INPUT PRIVATE PROTECTION + HEART TEXT: \n\n {} \n".format(
        cf.getHeart()))
    Zheart, Pheart, sigma = pp.PrivateProtection(cf.getHeart())
    print(
        "OUTPUT PRIVATE PROTECTION Z + HEART TEXT: \n\n {} \n".format(Zheart))
    distance = pp.recoveredDistance(Zheart, sigma)

    print(distance[0])
    print(distance[1])
    print(distance[2])
__author__ = 'akashkakumani'
import RandomizedResponse as rr
import ConvertFile as cf
from scipy.spatial import distance
import numpy as np


def RecoverDistanceRR(p,X):
    (n,k) = X.shape
    dist = []
    for i in range(0,n):
        row = []
        for j in range(0, n):
            if (i == j):
                row.append(0)
            else:
                #row.append("{} compared with {}".format(i,j))
                userA = X[i]
                userB = X[j]
                euc = distance.euclidean(userA, userB)**2
                tmp = (euc - (2*k*p)*(1-p))/((1-2*p)**2)
                row.append(tmp)
        dist.append(row)
    return np.array(dist)

output1 = rr.RandomizedResponse(0.4,cf.getHeart())
print(RecoverDistanceRR(0.4,output1))
Beispiel #15
0
def studentPP():
    output = cf.getStudent()
    Zstudent, Pstudent, sigma = pp.PrivateProtection(output)
    distance = pp.recoveredDistance(Zstudent, sigma)
    return distance
def studentPP():
    output = cf.getStudent()
    Zstudent, Pstudent, sigma = pp.PrivateProtection(output)
    distance = pp.recoveredDistance(Zstudent,sigma)
    return distance
def heartMatrix():
    matrix = cf.getHeart()
    dist = distance.squareform(distance.pdist(matrix, metric='euclidean'))
    return dist