itextsharp pdf to image c# : Cannot save pdf form in reader application SDK tool html .net windows online book13-part1758

3.1 Functions
101
3.1.7Multiplereturnvalues
Python functionsmayreturn more than one value. Suppose we are
interestedinevaluatingbothy(t)andy(t):
y(t)=v
0
t−
1
2
gt
2
,
y
(t) = v
0
−gt.
To return bothy andy we simply separate their corresponding variables
by a comma in the return statement:
def yfunc(t, v0):
g = 9.81
y = v0*t - 0.5*g*t**2
dydt = v0 - g*t
return y, dydt
Calling this latteryfunc function makes a need for two values on the
left-hand side of the assignment operator because the function returns
two values:
position, velocity = yfunc(0.6, 3)
Here is an application of theyfunc function for producing a nicely
formatted table of t, y(t), and y(t) values:
t_values = [0.05*i for i in range(10)]
for t in t_values:
position, velocity = yfunc(t, v0=5)
print ’t=%-10g position=%-10g velocity=%-10g’ % \
(t, position, velocity)
The format%-10g prints a real number as compactly as possible (decimal
or scientific notation) in a field of width 10 characters. The minus sign
(-) after the percentage sign implies that the number is left-adjusted in
this field, a feature that is important for creating nice-looking columns
in the output:
t=0
position=0
velocity=5
t=0.05
position=0.237737
velocity=4.5095
t=0.1
position=0.45095
velocity=4.019
t=0.15
position=0.639638
velocity=3.5285
t=0.2
position=0.8038
velocity=3.038
t=0.25
position=0.943437
velocity=2.5475
t=0.3
position=1.05855
velocity=2.057
t=0.35
position=1.14914
velocity=1.5665
t=0.4
position=1.2152
velocity=1.076
t=0.45
position=1.25674
velocity=0.5855
When a function returns multiple values, separated by a comma in
thereturn statement, a tuple (Section 2.5) is actually returned. We can
demonstrate that fact by the following session:
Cannot save pdf form in reader - C# PDF Field Edit Library: insert, delete, update pdf form field in C#.net, ASP.NET, MVC, Ajax, WPF
Online C# Tutorial to Insert, Delete and Update Fields in PDF Document
pdf form save with reader; allow saving of pdf form
Cannot save pdf form in reader - VB.NET PDF Field Edit library: insert, delete, update pdf form field in vb.net, ASP.NET, MVC, Ajax, WPF
How to Insert, Delete and Update Fields in PDF Document with VB.NET Demo Code
best way to make pdf forms; changing font in pdf form
102
3 Functions and branching
>>> def f(x):
...
return x, x**2, x**4
...
>>> s = f(2)
>>> s
(2, 4, 16)
>>> type(s)
<type ’tuple’>
>>> x, x2, x4 = f(2)
# store in separate variables
Note that storing multiple return values in separate variables, as we do
in the last line, is actually the same functionality as we use for storing
list (or tuple) elements in separate variables, see Section 2.2.1.
3.1.8 Computing sums
Our next example concerns a Python function for calculating the sum
L(x; n) =
n
i=1
1
i
x
1+ x
i
.
(3.1)
To compute a sum in a program, we use a loop and add terms to an
accumulation variable inside the loop. Section 2.1.4 explains the idea.
However, summation expressions with an integer counter, such asi in
(3.1), are normally implemented by afor loop over thei counter and
not awhile loop as in Section 2.1.4. For example, the implementation
of
n
i=1
i
2
is typically implemented as
s = 0
for i in range(1, n+1):
s += i**2
For the specific sum (3.1) we just replacei**2 by the right term inside
the for loop:
s = 0
for i in range(1, n+1):
s += (1.0/i)*(x/(1.0+x))**i
Observe the factors1.0 used to avoid integer division, sincei isint and
xmay also be int.
It is natural to embed the computation of the sum in a function that
takes x and n as arguments and returns the sum:
def L(x, n):
s = 0
for i in range(1, n+1):
s += (1.0/i)*(x/(1.0+x))**i
return s
Our formula (3.1) is not chosen at random. In fact, it can be shown
thatL(x;n) is an approximation toln (1 +x) for a finiten andx≥ 1.
The approximation becomes exact in the limit
C# PDF: PDF Document Viewer & Reader SDK for Windows Forms
SaveFile(String filePath): Save PDF document file to a specified path in a file dialog and load your PDF document in will be a pop-up window "cannot open your
add form fields to pdf; create a fillable pdf form from a pdf
VB.NET Create PDF Library SDK to convert PDF from other file
because you can make sure that the PDF file cannot be altered pages Dim doc As PDFDocument = PDFDocument.Create(2) ' Save the new created PDF document into
add fields to pdf form; change font size in fillable pdf form
3.1 Functions
103
lim
n→∞
L(x; n) = ln(1 + x) .
Computational significance of L(x; n)
Although we can compute ln (1 +x) on a calculator or by
math.log(1+x)inPython,youmayhavewonderedhowsucha
function is actually calculated inside the calculator or the math
module. In most cases this must be done via simple mathematical
expressions such as the sum in (3.1). A calculator and the math
module will use more sophisticated formulas than (3.1) for ultimate
efficiency of the calculations, but the main point is that the numeri-
cal values of mathematical functions likeln (x),sin (x), andtan (x)
are usually computed by sums similar to (3.1).
Instead of having ourL function just returning the value of the sum,
we could return additional information on the error involved in the
approximation ofln (1 +x) byL(x;n). The size of the terms decreases
with increasingn, and the first neglected term is then bigger than all
the remaining terms, but not necessarily bigger than their sum. The first
neglected term is hence an indication of the size of the total error we
make, so we may use this term as a rough estimate of the error. For
comparison, we could also return the exact error since we are able to
calculate the ln function by math.log.
Anew version of theL(x, n) function, where we return the value of
L(x; n), the first neglected term, and the exact error goes as follows:
def L2(x, n):
s = 0
for i in range(1, n+1):
s += (1.0/i)*(x/(1.0+x))**i
value_of_sum = s
first_neglected_term = (1.0/(n+1))*(x/(1.0+x))**(n+1)
from math import log
exact_error = log(1+x) - value_of_sum
return value_of_sum, first_neglected_term, exact_error
# typical call:
value, approximate_error, exact_error = L2(x, 100)
The next section demonstrates the usage of theL2 function to judge the
quality of the approximation L(x; n) to ln(1 + x).
3.1.9 Functions with no return values
Sometimes a function just performs a set of statements, without com-
puting objects that are natural to return to the calling code. In such
situations one can simply skip thereturn statement. Some programming
C# Image: How to Use C# Code to Capture Document from Scanning
installed on the client as browsers cannot interface directly Save a the customized multi-page document to a a multi-page document (including PDF, TIFF, Word
change font in pdf fillable form; adding text field to pdf
VB.NET Image: VB.NET Code to Add Rubber Stamp Annotation to Image
designed image and document, then you cannot miss RasterEdge image or document files; Able to save created rubber Suitable for VB.NET PDF, Word & TIFF document
pdf form creation; best program to create pdf forms
104
3 Functions and branching
languages use the terms procedure or subroutine for functions that do
not return anything.
Let us exemplify a function without return values by making a table of
the accuracy of theL(x;n) approximation toln (1 +x) from the previous
section:
def table(x):
print ’\nx=%g, ln(1+x)=%g’ % (x, log(1+x))
for n in [1, 2, 10, 100, 500]:
value, next, error = L2(x, n)
print ’n=%-4d %-10g (next term: %8.2e ’\
’error: %8.2e)’ % (n, value, next, error)
This function just performs a set of statements that we may want to run
several times. Calling
table(10)
table(1000)
gives the output
x=10, ln(1+x)=2.3979
n=1
0.909091
(next term: 4.13e-01 error: 1.49e+00)
n=2
1.32231
(next term: 2.50e-01 error: 1.08e+00)
n=10
2.17907
(next term: 3.19e-02 error: 2.19e-01)
n=100 2.39789
(next term: 6.53e-07 error: 6.59e-06)
n=500 2.3979
(next term: 3.65e-24 error: 6.22e-15)
x=1000, ln(1+x)=6.90875
n=1
0.999001
(next term: 4.99e-01 error: 5.91e+00)
n=2
1.498
(next term: 3.32e-01 error: 5.41e+00)
n=10
2.919
(next term: 8.99e-02 error: 3.99e+00)
n=100 5.08989
(next term: 8.95e-03 error: 1.82e+00)
n=500 6.34928
(next term: 1.21e-03 error: 5.59e-01)
From this output we see that the sum converges much more slowly when
xislargethanwhen xissmall.Wealsoseethattheerrorisanorderof
magnitude or more larger than the first neglected term in the sum. The
functions L, L2, and table are found in the file lnsum.py.
When there is no explicitreturn statement in a function, Python
actually inserts an invisiblereturn None statement.None is a special
object in Python that represents something we might think of as empty
data or just “nothing”. Other computer languages, such as C, C++, and
Java, use the word void for a similar thing. Normally, one will call the
tablefunctionwithoutassigningthereturnvaluetoanyvariable,butif
we assign the return value to a variable,result = table(500),result
will refer to a None object.
The None value is often used for variables that should exist in a
program, but where it is natural to think of the value as conceptually
undefined. The standard way to test if an objectobj is set toNone or
not reads
if obj is None:
...
if obj is not None:
...
VB.NET TIFF: VB.NET Sample Codes to Add Watermark in a TIFF Image
would not be obscured and cannot be removed for TIFF watermark embedding; Easily save updated TIFF powerful & profession imaging controls, PDF document, image
create a form in pdf; add text field to pdf acrobat
VB.NET Word: .NET Project for Merging Two or More Microsoft Word
REDocument), fileNameMerged, New DOCXEncoder()) 'save new word Unfortunately, it cannot be used in commercial profession imaging controls, PDF document, image
adding text to a pdf form; create pdf form
3.1 Functions
105
One can also useobj == None. Theis operator tests if two names refer
to the same object, while== tests if the contents of two objects are the
same:
>>> a = 1
>>> b = a
>>> a is b
# a and b refer to the same object
True
>>> c = 1.0
>>> a is c
False
>>> a == c
# a and c are mathematically equal
True
3.1.10 Keyword arguments
Some function arguments can be given a default value so that we may
leave out these arguments in the call. A typical function may look as
>>> def somefunc(arg1, arg2, kwarg1=True, kwarg2=0):
>>>
print arg1, arg2, kwarg1, kwarg2
The first two arguments,arg1 andarg2, are ordinary or positional argu-
ments, while the latter two are keyword arguments or named arguments.
Each keyword argument has a name (in this examplekwarg1 andkwarg2)
and an associated default value. The keyword arguments must always be
listed after the positional arguments in the function definition.
When callingsomefunc, we may leave out some or all of the keyword
arguments. Keyword arguments that do not appear in the call get their
values from the specified default values. We can demonstrate the effect
through some calls:
>>> somefunc(’Hello’, [1,2])
Hello [1, 2] True 0
>>> somefunc(’Hello’, [1,2], kwarg1=’Hi’)
Hello [1, 2] Hi 0
>>> somefunc(’Hello’, [1,2], kwarg2=’Hi’)
Hello [1, 2] True Hi
>>> somefunc(’Hello’, [1,2], kwarg2=’Hi’, kwarg1=6)
Hello [1, 2] 6 Hi
The sequence of the keyword arguments does not matter in the call. We
may also mix the positional and keyword arguments if we explicitly write
name=value for all arguments in the call:
>>> somefunc(kwarg2=’Hello’, arg1=’Hi’, kwarg1=6, arg2=[1,2],)
Hi [1, 2] 6 Hello
Example: Function with default parameters. Considerafunctionoft
which also contains some parameters, here A, a, and ω:
C# TIFF: C#.NET Code to Create Windows TIFF Viewer | Online
document annotating support; Simple to save and output would be an notice with "cannot open your file powerful & profession imaging controls, PDF document, image
add fields to pdf; add text fields to pdf
C# Image: Create C#.NET Windows Document Image Viewer | Online
viewing multiple document & image formats (PDF, MS Word SaveFile(String filePath): Save loaded file to a specified there will prompt a window "cannot open your
add attachment to pdf form; edit pdf form
106
3 Functions and branching
f(t; A, a, ω) = Ae
−at
sin(ωt) .
(3.2)
We can implementf as a Python function where the independent variable
tisanordinarypositionalargument,andtheparameters A, a,and ω
are keyword arguments with suitable default values:
from math import pi, exp, sin
def f(t, A=1, a=1, omega=2*pi):
return A*exp(-a*t)*sin(omega*t)
Calling f with just the t argument specified is possible:
v1 = f(0.2)
In this case we evaluate the expressione−0.2sin (2π·0.2). Other possible
calls include
v2 = f(0.2, omega=1)
v3 = f(1, A=5, omega=pi, a=pi**2)
v4 = f(A=5, a=2, t=0.01, omega=0.1)
v5 = f(0.2, 0.5, 1, 1)
You should write down the mathematical expressions that arise from
these four calls. Also observe in the third line above that a positional
argument,t in that case, can appear in between the keyword arguments
if we write the positional argument on the keyword argument form
name=value.Inthelastlinewedemonstratethatkeywordarguments
can be used as positional argument, i.e., the name part can be skipped,
but then the sequence of the keyword arguments in the call must match
the sequence in the function definition exactly.
Example: Computing a sum with default tolerance. Consider the
L(x; n)sumandthePythonimplementations L(x, n) and L2(x, n)
from Section 3.1.8. Instead of specifying the number of terms in the sum,
n,itisbettertospecifyatolerance εoftheaccuracy.Wecanusethe
first neglected term as an estimate of the accuracy. This means that we
sum up terms as long as the absolute value of the next term is greater
than �. It is natural to provide a default value for �:
def L3(x, epsilon=1.0E-6):
x = float(x)
i = 1
term = (1.0/i)*(x/(1+x))**i
s = term
while abs(term) > epsilon:
i += 1
term = (1.0/i)*(x/(1+x))**i
s += term
return s, i
Here is an example involving this function to make a table of the
approximation error as � decreases:
def table2(x):
from math import log
for k in range(4, 14, 2):
C# Excel: View Excel File in Window Document Viewer Control
Easy to view, edit, annotate and save Excel (.xlsx there will prompt a window "cannot open your file powerful & profession imaging controls, PDF document, image
can save pdf form data; chrome save pdf form
C# PowerPoint: Document Viewer Creating in Windows Forms Project
C#.NET users to edit, annotate and save PowerPoint document NET tutorial, we will take a blank form as an control, there will prompt a window "cannot open your
cannot edit pdf form; pdf save form data
3.1 Functions
107
epsilon = 10**(-k)
approx, n = L3(x, epsilon=epsilon)
exact = log(1+x)
exact_error = exact - approx
The output from calling table2(10) becomes
epsilon: 1e-04, exact error: 8.18e-04, n=55
epsilon: 1e-06, exact error: 9.02e-06, n=97
epsilon: 1e-08, exact error: 8.70e-08, n=142
epsilon: 1e-10, exact error: 9.20e-10, n=187
epsilon: 1e-12, exact error: 9.31e-12, n=233
We see that theepsilon estimate is almost 10 times smaller than the
exact error, regardless of the size of epsilon. Since epsilon follows
the exact error quite well over many orders of magnitude, we may view
epsilon as a useful indication of the size of the error.
3.1.11 Doc strings
There is a convention in Python to insert a documentation string right
after thedef line of the function definition. The documentation string,
known as a doc string, should contain a short description of the purpose
of the function and explain what the different arguments and return
values are. Interactive sessions from a Python shell are also common to
illustrate how the code is used. Doc strings are usually enclosed in triple
double quotes """, which allow the string to span several lines.
Here are two examples on short and long doc strings:
def C2F(C):
"""Convert Celsius degrees (C) to Fahrenheit."""
return (9.0/5)*C + 32
def line(x0, y0, x1, y1):
"""
Compute the coefficients a and b in the mathematical
expression for a straight line y = a*x + b that goes
through two points (x0, y0) and (x1, y1).
x0, y0: a point on the line (floats).
x1, y1: another point on the line (floats).
return: coefficients a, b (floats) for the line (y=a*x+b).
"""
a = (y1 - y0)/float(x1 - x0)
b = y0 - a*x0
return a, b
Note that the doc string must appear before any statement in the function
body.
There are several Python tools that can automatically extract doc
strings from the source code and produce various types of documentation.
The leading tools is Sphinx
3
,see also [14, Appendix B.2].
The doc string can be accessed in a code asfuncname.__doc__, where
funcname is the name of the function, e.g.,
3
http://sphinx-doc.org/invocation.html#invocation-apidoc
108
3 Functions and branching
print line.__doc__
which prints out the documentation of the line function above:
Compute the coefficients a and b in the mathematical
expression for a straight line y = a*x + b that goes
through two points (x0, y0) and (x1, y1).
x0, y0: a point on the line (float objects).
x1, y1: another point on the line (float objects).
return: coefficients a, b for the line (y=a*x+b).
If the function line is in a file funcs.py, we may also run pydoc
funcs.line ina terminal window tolookthe documentationof the
line function in terms of the function signature and the doc string.
Doc strings often contain interactive sessions, copied from a Python
shell, to illustrate how the function is used. We can add such a session
to the doc string in the line function:
def line(x0, y0, x1, y1):
"""
Compute the coefficients a and b in the mathematical
expression for a straight line y = a*x + b that goes
through two points (x0,y0) and (x1,y1).
x0, y0: a point on the line (float).
x1, y1: another point on the line (float).
return: coefficients a, b (floats) for the line (y=a*x+b).
Example:
>>> a, b = line(1, -1, 4, 3)
>>> a
1.3333333333333333
>>> b
-2.333333333333333
"""
a = (y1 - y0)/float(x1 - x0)
b = y0 - a*x0
return a, b
Aparticularly nice feature is that all such interactive sessions in doc
strings can be automatically run, and new results are compared to the
results found in the doc strings. This makes it possible to use interactive
sessions in doc strings both for exemplifying how the code is used and
for testing that the code works.
Function input and output
It is a convention in Python that function arguments represent the
input data to the function, while the returned objects represent the
output data. We can sketch a general Python function as
def somefunc(i1, i2, i3, io4, io5, i6=value1, io7=value2):
# modify io4, io5, io6; compute o1, o2, o3
return o1, o2, o3, io4, io5, io7
3.1 Functions
109
Herei1,i2,i3 are positional arguments representing input data;
io4and io5arepositionalargumentsrepresentinginputandoutput
data;i6 andio7 are keyword arguments representing input and
input/output data, respectively; and o1, o2, and o3 are computed
objects in the function, representing output data together withio4,
io5, and io7. All examples later in the book will make use of this
convention.
3.1.12 Functions as arguments to functions
Programs doing calculus frequently need to have functions as arguments
in functions. For example, a mathematical functionf(x) is needed in
Python functions for
numericalrootfinding:solve f(x)=0approximately(Sections4.10.2
and A.1.10)
numericaldifferentiation:compute f(x)approximately(SectionsB.2
and 7.3.2)
numericalintegration:compute
b
a
f(x)dxapproximately(SectionsB.3
and 7.3.3)
•numerical solution of differential equations:
dx
dt
=f (x) (Appendix E)
In such Python functions we need to have the f (x) function as an
argument f. This is straightforward in Python and hardly needs any
explanation, but in most other languages special constructions must be
used for transferring a function to another function as argument.
As an example, consider a function for computing the second-order
derivative of a function f(x) numerically:
f
��
(x) ≈
f(x − h) − 2f(x) + f (x + h)
h2
,
(3.3)
whereh is a small number. The approximation (3.3) becomes exact in the
limith→ 0. A Python function for computing (3.3) can be implemented
as follows:
def diff2nd(f, x, h=1E-6):
r = (f(x-h) - 2*f(x) + f(x+h))/float(h*h)
return r
Thef argument is like any other argument, i.e., a name for an object,
here a function object that we can call as we normally call functions. An
application of diff2nd may be
def g(t):
return t**(-6)
t = 1.2
110
3 Functions and branching
d2g = diff2nd(g, t)
print "g’’(%f)=%f" % (t, d2g)
The behavior of the numerical derivative as h →0.Frommathematics
we know that the approximation formula (3.3) becomes more accurate as
hdecreases.Letustrytodemonstratethisexpectedfeaturebymaking
atable of the second-order derivative of g(t) = t
−6
at t = 1 as h → 0:
for k in range(1,15):
h = 10**(-k)
d2g = diff2nd(g, 1, h)
print ’h=%.0e: %.5f’ % (h, d2g)
The output becomes
h=1e-01: 44.61504
h=1e-02: 42.02521
h=1e-03: 42.00025
h=1e-04: 42.00000
h=1e-05: 41.99999
h=1e-06: 42.00074
h=1e-07: 41.94423
h=1e-08: 47.73959
h=1e-09: -666.13381
h=1e-10: 0.00000
h=1e-11: 0.00000
h=1e-12: -666133814.77509
h=1e-13: 66613381477.50939
h=1e-14: 0.00000
Withg(t) =t
−6
,the exact answer isg
��
(1) = 42, but forh< 10
−8
the
computations give totally wrong answers! The problem is that for smallh
on a computer, round-off errors in the formula (3.3) blow up and destroy
the accuracy. The mathematical result that (3.3) becomes an increasingly
better approximation ash gets smaller and smaller does not hold on a
computer! Or more precisely, the result holds untilh in the present case
reaches 10−4.
The reason for the inaccuracy is that the numerator in (3.3) for
g(t)= t−6 and t=1containssubtractionofquantitiesthatarealmost
equal. The result is a very small and inaccurate number. The inaccuracy
is magnified by h−2, a number that becomes very large for small h.
Switching from the standard floating-point numbers (float) to
numbers with arbitrary high precision resolves the problem. Python
has a module decimal that can be used for this purpose. The file
high_precision.pysolvesthecurrentproblemusingarithmeticsbased
on thedecimal module. With 25 digits inx andh inside thediff2nd
function, we get accurate results forh≤ 10
−13
.However, for most practi-
cal applications of (3.3), a moderately smallh, say 10−3 ≤h≤ 10−4, gives
sufficient accuracy and then round-off errors fromfloat calculations do
not pose problems. Real-world science or engineering applications usually
have many parameters with uncertainty, making the end result also
uncertain, and formulas like (3.3) can then be computed with moderate
accuracy without affecting the overall uncertainty in the answers.
Documents you may be interested
Documents you may be interested