How to process high-precision blind holes?

How to process high-precision blind holes?

When using a keyway milling cutter to process flat pits, there is no problem with the diameter of the hole, which can be guaranteed to be 0.02mm. The depth accuracy of the hole depends on what machine tool you are using. If you are using a CNC milling machine, the depth accuracy should be fine. If you are using a drill press, the depth of the hole should be controlled to 0.1mm.

Blind holes are located on the top and bottom surfaces of printed circuit boards and have a certain depth. They are used to connect surface circuits and underlying inner circuits. The depth of the holes usually does not exceed a certain ratio (aperture).

Blind vias are via holes that connect the surface layer and the inner layer without penetrating the entire page.

Buried vias refer to via holes that connect inner layers but are not visible on the surface of the finished board. The above two types of holes are located in the inner layer of the circuit board. They are completed using the through-hole forming process before lamination. During the via-hole formation process, several inner layers may be overlapped.

Find Pascal's high-precision subtraction, high-precision multiplication, and high-precision addition of 1 to n. These three questions

High-precision subtraction

The high-precision subtraction program is as follows:

< p> Program HighPrecision2_Subtract;

const

fn_inp='hp2.inp';

fn_out='hp2.out';

maxlen=100; {the maximum length of a number}

type

hp=record

len:integer; {the length of a number}

s:array[1..maxlen] of integer

{ s[1] is the lowest bit, s[len] is the highest bit}

end;

< p> var

x:array[1..2] of hp;

y:hp; { x: input; y: output}

positive :boolean;

procedure PrintHP(const p:hp);

var i:integer;

begin

for i:= p.len downto 1 do write(p.s[i]);

end;

procedure init;

var

st: string;

j,i:integer;

begin

assign(input,fn_inp);

reset(input);< /p>

for j:=1 to 2 do

begin

readln(st);

x[j].len:=length (st);

for i:=1 to x[j].len do { change string to HP }

x[j].s[i]:=ord( st[x[j].len+1-i])-ord('0');

end;

close(input);

end;

procedure Subtract(a,b:hp;var c:hp); { c:=a-b, suppose a>=b }

var i,len:integer;

begin

fillchar(c,sizeof(c),0);

if a.len>b.len then len:=a.len { get the bigger length of a,b }

else len:=b.len;

for i:=1 to len do { subtract from low to high }

begin

inc(c.s[i],a.s[i]-b.s[i]);

if c.s[i]<0 then

begin

inc(c.s[i],10);

dec(c.s[i+1]); { add 1 to a higher position }

end;

end;

while(len>1) and (c.

s[len]=0) do dec(len);

c.len:=len;

end;

function Compare(const a,b :hp):integer;

{

1 if a>b

0 if a=b

-1 if a < b

}

var len:integer;

begin

if a.len>b.len then len:=a. len { get the bigger length of a,b }

else len:=b.len;

while(len>0) and (a.s[len]=b.s[len] ) do dec(len);

{ find a position which have a different digit }

if len=0 then pare:=0 { no difference }

else pare:=a.s[len]-b.s[len];

end;

procedure main;

begin

if pare(x[1],x[2])<0 then positive:=false

else positive:=true;

if positive then Subtract(x[1],x [2],y)

else Subtract(x[2],x[1],y);

end;

procedure out;

p>

begin

assign(output,fn_out);

rewrite(output);

if not positive then write('-');

PrintHP(y);

writeln;

close

(output);

end;< /p>

begin

init;

main;

out;

end.

High precision multiplication by high precision

The program is as follows:

Program HighPrecision4_Multiply2;

const

fn_inp='hp4.inp';

p>

fn_out='hp4.out';

maxlen=100; { max length of the number }

type

hp=record< /p>

len:integer; { length of the number }

s:array[1..maxlen] of integer

{ s[1] is the lowest position

s[len] is the highest position }

end;

var

x:array[1..2] of hp;

y:hp; { x:input;

y:output }

procedure PrintHP(const p:hp);

var i:integer;

begin

for i: =p.len downto 1 do write(p.s[i]);

end;

procedure init;

var

st :string;

j,i:integer;

begin

assign(input,fn_inp);

reset(input);

for j:=1 to 2 do

begin

readln(st);

x[j].len:= length(st);

for i:=1 to x[j].len do { change string to HP }

x[j].s[i]:=ord (st[x[j].len+1-i])-ord('0');

end;

close(input);

end;

procedure Multiply(a,b:hp;var c:hp); { c:=a+b }

var i,j,len:integer;< /p>

begin

fillchar(c,sizeof(c),0);

for i:=1 to a.len do

for j:=1 to b.len do

begin

inc(c.s[i+j-1],a.s[i]*b.s[j]);

inc(c.s[i+j],c.s[i+j-1] div 10);

c.s[i+j-1]:=c.s[i+j-1] mod 10;

end;

len:=a.len+b.len+1;

{

the product of a number with i digits and a number with j digits

can only have at most i+j+1 digits

}

while(len>1) and(c.s[len]=0) do dec(len);

c.len:=len;

end;

procedure main;

p>

begin

Multiply(x[1],x[2],y);

end;

procedure out;

begin

assign(output,fn_out);

rewrite(output);

PrintHP(y);

writeln;

close(output);

end;

begin

init;

main;< /p>

out;

end.

As for the addition of 1 to N, it is obviously N(N+1)/2, so division...

.High-precision division of integer data (integer);<

/p>

The program is as follows:

Program HighPrecision3_Multiply1;

const

fn_inp='hp5.inp';

fn_out ='hp5.out';

maxlen=100; { max length of the number }

type

hp=record

len:integer; { length of the number }

s:array[1..maxlen] of integer

{ s[1] is the lowest position

s[len] is the highest position }

end;

var

x,y:hp;

z,w :integer;

procedure PrintHP(const p:hp);

var i:integer;

begin

for i:= p.len downto 1 do write(p.s[i]);

end;

procedure init;

var

st: string;

i:integer;

begin

assign(input,fn_inp);

reset(input);

readln(st);

x.len:=length(st);

for i:=1 to x.len do { change string to HP }< /p>

x.s[i]:=ord(st[x.len+1-i])-ord('0');

readln(z);

< p> close(input);

end;

procedure Divide(a:hp;b:integer;var c:hp;var d:integer);

< p> { c:=a div b ; d:=a mod b }

var i,len:integer;

begin

fillchar(c, sizeof(c),0);

len:=a.len;

d:=0;

for i:=len downto 1 do { from high to low }

begin

d:=d*1a.s[i];

c.s[i]:=d div b;< /p>

d:=d mod b;

end;

while(len>1) and (c.s[len]=0) do dec(len);

c.len:=len;

end;

procedure main;

begin

Divide( x,z,y,w);

end;

procedure out;

begin

assign(output,fn_out);

r

ewrite(output);

PrintHP(y);

writeln;

writeln(w);

close(output);

end;

begin

init;

main;

out;

end.

Just divide by 2 of an integer type.

This is how to ask for high-precision division algorithm

High-precision division is high-precision subtraction. On a deeper level, in fact, the idea of ????high precision is that when we usually calculate problems, the vertical expressions are the same. For example, if the calculation from right to left is from right to left, then carry is carried if the calculation is greater than 10. The same is true for subtraction, except that if there is not enough subtraction, The carry variable in addition becomes the borrow variable (for example, t is this variable. When the addition is executed, the two variables a and b are two numbers in the same position of the two numbers. If a+b>10, then t -->1 If it is subtraction, if a-b<0 t--> -1, t must be added to each operation. Of course, after judging which digit to add, the answer must be processed (addition -10, subtraction a+10 -b).

As for your question, I don’t know how to deal with it, but I think it would be too complicated to use high precision. Generally, to find the greatest common divisor and least common multiple, use euclidean Division, I think this question should be an improved form of this method is the best method.

Find Pascal's high-precision multiplication algorithm

Definition of high-precision numbers:

type

hp=array[0..maxlen] of integer;< /p>

1. High-precision addition

procedure plus(a, b: hp; var c: hp);

var

i, Len: Integer;

begin

FillChar(c, SizeOf(c), 0);

if a[0] > b[0] then

Len: = a[0]

else

Len := b[0];

for i := 1 to Len do

begin

Inc(c[i], a[i] + b[i]);

if c[i] >= 10 then

begin

Dec(c[i], 10);

Inc(c[i + 1]);

end;

end;

if c[Len + 1] > 0 then

Inc(Len);

c[0] := Len;

end;

2. High-precision subtraction

procedure substract(a, b: hp; var c: hp);

var

i, Len: Integer;

begin

FillChar(c, SizeOf(c), 0);

if a[0] > b[0] then

Len: = a[0]

else

Len := b[0];

for i := 1 to Len do

begin

Inc(c[i], a[i] - b[i]);

if c[i] < 0 then

begin< /p>

Inc(c[i], 10);

Dec(c[i + 1]);

end;

end ;

while (Len > 1) and (c[Len] = 0) do

Dec(Len);

c[0] := Len ;

end;

3. High precision multiplied by low precision

procedure multiply(a: hp; b: Longint; var c: hp);

var

i, Len: Integer ;

begin

FillChar(c, SizeOf(c), 0);

Len := a[0];

for i := 1 to Len do

begin

Inc(c[i], a[i] * b);

Inc(c[i + 1], c[i] div 10);

c[i] := c[i] mod 10;

end;

Inc( Len);

while (c[Len] &

gt;= 10) do

begin

c[Len + 1] := c[Len] div 10;

c[Len] := c [Len] mod 10;

Inc(Len);

end;

while (Len > 1) and (c[Len] = 0) do

Dec(Len);

c[0] := Len;

end;

4. High precision times high precision

procedure high_multiply(a, b: hp; var c: hp)

var

i, j, Len: Integer;

begin

FillChar(c, SizeOf(c), 0);

for i := 1 to a[0] do

< p> for j := 1 to b[0] do

begin

Inc(c[i + j - 1], a[i] * b[j]);

Inc(c[i + j], c[i + j - 1] div 10);

c[i + j - 1] := c[i + j - 1] mod 10;

end;

Len := a[0] + b[0] + 1;

while (Len > 1) and (c[Len] = 0) do

Dec(Len);

c[0] := Len;

end;

5. High precision divided by low precision

procedure devide(a: hp; b: Longint; var c: hp; var d: Longint);

var

i, Len: Integer;

begin

FillChar(c, SizeOf(c), 0);

Len := a[0];

p>

d := 0;

for i := Len downto 1 do

begin

d := d * 10 + a[i ];

c[i] := d div b;

d := d mod b;

end;

while (Len > 1) and (c[Len] = 0) then

Dec(Len);

c[0] := Len;

end ;

6. High precision divided by high precision

procedure high_devide(a, b: hp; var c, d: hp);

var

i, Len: Integer ;

begin

FillChar(c, SizeOf(c), 0);

FillChar(d, SizeOf(d), 0);

Len := a[0];

d[0] := 1;

for i := Len downto 1 do

begin

multiply(d, 10, d);

d[1] := a[i];

while (pare(d, b) >= 0) do

begin

Subtract(d, b, d);

Inc(c[i]);

end;

end;

while (Len > 1 ) and (c.s[Len] = 0) do

Dec(Len);

c.Len := Len;

end;

Compare the size than the length to the size from the low to the high, and no longer repeat them here.

Ahhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhly You can solve it by converting ordinary numbers into high-precision ones

High-precision round hole processing methods and low-precision round hole processing methods. What are the good methods for high-precision small hole processing

< p> Processing methods for high-precision round holes: 1. Reaming. 2. Grind the hole. 3. Boring. 4. Grind the hole. 5. Pull boring. 6. Squeeze. 7. Laser cutting.

General precision round hole processing methods: 1. Drilling. 2. Wire cutting. 3. Water jet cutting.

Methods for low-precision round hole processing: 1. Acetylene oxygen cutting. How to write the slogan "Improving precision production and high-precision quality"

1. Quality is the eternal theme of an enterprise.

2. The market is the sea, quality is the ship, and brand is the sail.

3. Today’s quality, tomorrow’s market.

4. Build the Great Wall of Quality and revitalize the Chinese economy.

5. ISO9000—the source of efficiency and effectiveness.

6. Construct an integrated management system of “quality, environment and safety”.

7. Establish a quality system with quality culture to create attractive and soulful quality.

8. Future success belongs to the century of quality leaders.

9. The 21st century - the century of quality leaders.

10. Only quality can create brilliance.

11. Quality is more important than cost.

12. Survive by quality, develop by quality, and gain benefits from quality.

13. Survive by quality and develop by reform.

14. Qualified quality is a social obligation, and excellent quality is a contribution to society.

15. Quality is the partner of success, and standard implementation is the guarantee of quality.

16. Say goodbye to traditional yesterday and move towards a normative future.

17. Only by stepping into the track of international standards can there be unlimited room for expansion.

18. Users are the source of enterprise development.

19. Face up to the crisis, enhance confidence, work hard and create greater glory.

20. Enhance the sense of urgency, strengthen the sense of responsibility, make every effort to seize the market, and fight for a turnaround.

21. Being able to go up and down, being able to enter and exit is the only way to lift, and only ability is to use.

22. Change concepts, change styles, innovate mechanisms, and innovate situations.

23. Inject life into the product, and the product will come alive in the market.

24. Manufacturing must rely on low cost, and competition relies on high quality.

25. Integrate the business philosophy with hard work and keep the corporate culture alive.

26. Establish core values ??and be good at learning and creating.

27. Quality is the life of an enterprise.

28. Quality - the key to corporate success.

Where to find high-precision aperture measurement tools?

Can I find Beijing Yislaifu Y54 rack gear shaping machine that can process high-precision racks?

It can only process products below level eight, but not above level seven. High-precision can only be processed with CNC gear shaper YK58125A. How to buy high-precision 0.1 ohm resistors

Accuracy What is the grade of the 0.1 ohm resistor box?

It is grade 4

-----------

If your question is true The question is how to get a 0.1 ohm resistor,

You don’t actually need to buy it:

How to make a 0.1 ohm resistor yourself

Use copper with a diameter of 0.1cm Silk, 20cm is almost enough.