? outative;

Calculate

? outative;

Calculate

### outative

Run Example
```(%i1)a: 1/(c-d)-c/(c^2-d^2)+1/(2*c+2*d);
c          1         1
(%o1)                    - ------- + --------- + -----
2    2   2 d + 2 c   c - d
c  - d
(%i2) xthru(a);
2    2
(d + 3 c) (c  - d ) - c (c - d) (2 d + 2 c)
(%o2)             -------------------------------------------
2    2
(c - d) (2 d + 2 c) (c  - d )
(%i3) b:ratsimp(a);
1
(%o3)                             - ---------
2 d - 2 c
(%i4) fullratsimp(a);
1
(%o4)                             - ---------
2 d - 2 c
(%i5) outative(2*c+2*d);
(%o5)                         outative(2 d + 2 c)
(%i6) ```
Run Example
```Px:Vx*t;
(%o1)                                t Vx
(%i2) Py:Vy*t;
(%o2)                                t Vy
(%i3) Pz:Vz*t;
(%o3)                                t Vz
(%i4) Rx:Px+Ux*s;
(%o4)                             t Vx + s Ux
(%i5) Ry:Py+Uy*s;
(%o5)                             t Vy + s Uy
(%i6) Rz:Pz+Uz*s;
(%o6)                             t Vz + s Uz
(%i7) m:subst(s=0,Rx^2+Ry^2=Rz);
2   2    2   2
(%o7)                       t  Vy  + t  Vx  = t Vz
(%i8) solve(m, t);
Vz
(%o8)                       [t = ---------, t = 0]
2     2
Vy  + Vx
(%i9) n:subst(s=1,Rx^2+Ry^2=Rz);
2              2
(%o9)               (t Vy + Uy)  + (t Vx + Ux)  = t Vz + Uz
(%i10) display2d:false;

(%o10) false
(%i11)
leftjust:true;

(%o11) true
(%i12)
solve(n, t);

(%o12) [t = -(sqrt(Vz^2+(-4*Uy*Vy-4*Ux*Vx)*Vz+(4*Uz-4*Ux^2)*Vy^2+8*Ux*Uy*Vx*Vy
+(4*Uz-4*Uy^2)*Vx^2)
-Vz+2*Uy*Vy+2*Ux*Vx)
/(2*Vy^2+2*Vx^2),
t = (sqrt(Vz^2+(-4*Uy*Vy-4*Ux*Vx)*Vz+(4*Uz-4*Ux^2)*Vy^2+8*Ux*Uy*Vx*Vy
+(4*Uz-4*Uy^2)*Vx^2)
+Vz-2*Uy*Vy-2*Ux*Vx)
/(2*Vy^2+2*Vx^2)]
(%i13)
q:-(sqrt(Vz^2+(-4*Uy*Vy-4*Ux*Vx)*Vz+(4*Uz-4*Ux^2)*Vy^2+8*Ux*Uy*Vx*Vy+(4*Uz-4*Uy^2)*Vx^2)-Vz+2*Uy*Vy+2*Ux*Vx)/(2*Vy^2+2*Vx^2);

(%o13) (-sqrt(Vz^2+(-4*Uy*Vy-4*Ux*Vx)*Vz+(4*Uz-4*Ux^2)*Vy^2+8*Ux*Uy*Vx*Vy
+(4*Uz-4*Uy^2)*Vx^2)
+Vz-2*Uy*Vy-2*Ux*Vx)
/(2*Vy^2+2*Vx^2)
(%i14)
declare(q, outative);

(%o14) done
(%i15)
```
Run Example
```? outative;

-- Declaration: outative
`declare (f, outative)' tells the Maxima simplifier that constant
factors in the argument of `f' can be pulled out.

1. If `f' is univariate, whenever the simplifier encounters `f'
applied to a product, that product will be partitioned into
factors that are constant and factors that are not and the
constant factors will be pulled out.  E.g., `f(a*x)' will
simplify to `a*f(x)' where `a' is a constant.  Non-atomic
constant factors will not be pulled out.

2. If `f' is a function of 2 or more arguments, outativity is
defined as in the case of `sum' or `integrate', i.e., `f
(a*g(x), x)' will simplify to `a * f(g(x), x)' for `a' free
of `x'.

`sum', `integrate', and `limit' are all `outative'.

(%o1)                                true
(%i2) ```

### Related Help

Help for Outative