Generate a set of random values based on seed
unif.seed_value is very un-Pythonic. Instead use a class.
Rather than using getattr(unif, "seed_value",0), you can make self.seed_value at object instantiation, and use that as the default, unless it's falsy, where it'd instead use seed.
math.floor is mostly the same as int. If you're using this on division, you can change it to floor divisions using //.
numpy.int32 is odd, it adds a dependency to numpy that shouldn't be needed. Instead you can use &amp; or %, this also means that it doesn't throw an error if the number is greater than (1 &lt;&lt; 31) - 1.
unif.seed_value/float(m) is the same as unif.seed_value/m in Python 3. In Python 2 it'd do floor division, unless one number is a float.
generate_flow_shop shouldn't need to take output, that should be implemented in main.
generate_flow_shop should take a single problem rather than the list of problems.
You can use tuple unpacking to give all values in the problem a name.
I heavily recommend str.format over the old % formatting operator. It has less bugs, and is enhanced in 3.6 with f-strings.
You can use _ as a 'throw away variable' in Python, it's somewhat a standard and lets developers ignore that variable, greatly increasing readability.


unif uses some fairly odd math, and so I decided to go for a more succinct approach.
And so I'd change your code to: (note, it's untested)

class Random:
    def __init__(self):
        self.seed_value = None

    def unif(self, seed, low, high):
        seed_value = self.seed_value or seed

        a = 16807
        b = 127773
        c = 2836
        m = (1 &lt;&lt; 31) - 1

        seed_value = (a * (seed_value % b) - (seed_value // b) * c)

        self.seed_value = (seed_value + (seed_value &lt; 0)) &amp; m
        return int(low + self.seed_value / m * (high - low + 1))

    def generate_flow_shop(self, problem):
        """Generates a flow shop problem set for a set in problem tuple and\
                writes to file in output"""

        time_seed, num_jobs, num_mach = problem
        r = [
            [
                self.unif(time_seed, 1, 99)
                for _ in range(num_jobs)
            ]
            for _ in range(num_mach)
        ]
        self.seed_value = None
        return r


def main():
    name = input("Enter filename to write the generated values:\n&gt; ")
    seedfile = input("Enter filename of the seed values:\n&gt; ")
    r = Random()

    with open(seedfile) as in_file:
        problems = [
            tuple(map(int, line.strip().split()))
            for line in in_file
            if line[0] != "#"
        ]

    with open(name, "w") as out_file:
        for i, problem in enumerate(problems):
            out_file.write("p {0:04} {1[1]} {1[2]}\n".format(i, problem)))
            data = r.generate_flow_shop(problem)
            out_file.write(''.join(' '.join(line) + '\n' for line in data))


if __name__ == '__main__':
    main()