Linear Function Solver from Two Points (x,y) The Task
Write a function L() that takes two Tuple arguments of coordinates in the form (x, y), and returns their respective linear function in the form (a, c), where a is the co-efficent of the x term and c is the y-intercept.
You can assume that the input will not be a line perpendicular the the x axis, and that the two inputs are separate points.
Scoring 
This is Code Golf: shortest program wins.
Please Note: No use of any mathematical functions apart from basic operators (+,-,/,*).
Example
Here is my un-golfed solution in Python.
def L(Point1, Point2):
    x = 0
    y = 1
    Gradient = (float(Point1[y]) - float(Point2[y])) / (float(Point1[x]) - float(Point2[x]))
    YIntercept = Point1[y] - Gradient * Point1[x] 
    return (Gradient, YIntercept)

Output:
&gt;&gt;&gt; L( (0,0) , (1,1) )
(1.0, 0.0)

&gt;&gt;&gt; L( (0,0) , (2,1) )
(0.5, 0.0)

&gt;&gt;&gt; L( (0,0) , (7,1) )
(0.14285714285714285, 0.0)

&gt;&gt;&gt; L( (10,22.5) , (5,12.5) )
(2.0, 2.5)
GNU dc, 30 24 bytes
[sysxly-rlx-/dlx*lyr-]sL

Defines a macro L such that
(x1, y1, x2, y2) should be pushed to the stack in that order before calling, and after calling L, (a, c) may be popped from the stack (in reverse order of course - it is a stack).
Testcase (save as &quot;linear.dc&quot; and run dc linear.dc):

[sysxly-rlx-/dlx*lyr-]sL   # Define L macro

10                         # Push x1 to the stack
22.5                       # Push y1 to the stack
5                          # Push x2 to the stack
12.5                       # Push y2 to the stack

lLx                        # Call L macro
f                          # Dump the stack

Output is:

$ dc linear.dc 
2.5
2
$ 

Explanation of L macro:

sy pop y2 to y register
sx pop x2 to x register
ly push y register (y2)
- subtract y2 from y1
r swap (y1 - y2) and x1 on stack
lx push x register (x2)
- subtract x2 from x1
/ divide (y1 - y2) by (x1 - x2) to get gradient
d duplicate gradient
lx push x register (x2)
* multiply (x2) by gradient
ly push y register (y2)
r swap (y2) and (x2 * gradient) on stack
- subtract (x2 * gradient) from (y2)