How to implement this kind of division?

[restive jay]

Look at the paper and see that weird division going on, how to do that with typst?

[simple vault]

I do not believe that's a Unicode symbol, so you would have to draw it yourself

[vale river]

I can't even find the correct terminology for that lol

To look if latex has a package for it

[simple vault]

I suspect it might be something the authors invented

[vale river]

Does seem like it

[feral hedge]

?render theme=light

#let ldiv(num, den) = {
  let num = $ num $
  let den = $ den $

  let stack-spacing = 0.4em
  let line-thickness = 0.5pt
  let line-offset = 0.0em
  let length-of-ends = 0.2em

  let type-of-turn = "square" // try "square", "circle" or "none"

  let turn = if type-of-turn == "square" {
    square(fill: black, stroke: none, size: line-thickness)
  } else if type-of-turn == "circle" {
    circle(fill: black, stroke: none, radius: line-thickness / 2)
  } else if type-of-turn not in ("none", none) { panic("Unexpected type of end: " + type-of-turn) }
  
  stack(spacing: stack-spacing, num, style(styles => {
    let num-width = measure(num, styles).width
    let den-width = measure(den, styles).width
    let width = calc.max(num-width, den-width)
    
    place(
      dx: -width / 2, dy: line-offset,
      line(stroke: line-thickness, length: width)
    )
    
    place(
      dx: -width / 2, dy: line-offset,
      line(stroke: line-thickness, length: length-of-ends, angle: 90deg)
    )
    
    place(
      dx: width / 2, dy: line-offset,
      line(stroke: line-thickness, length: length-of-ends, angle: -90deg)
    )

    place(
      dx: -width / 2 - line-thickness / 2,
      dy: line-offset - line-thickness / 2,
      turn,
    )
    place(
      dx: width / 2 - line-thickness / 2,
      dy: line-offset - line-thickness / 2,
      turn,
    )
  }), den)
}

$ ldiv(a - b, a) $
$ (a - b) / a $

[simple vault]

It looks like in the paper the numerator is offset to the left relative to the denominator

It looks super ugly though, so I prefer the centered approach that you did @feral hedge

[feral hedge]

Idk actually, the shift to the left might look nice because the line itself is asymmetrical

[simple vault]

Hm

[lament perch]

my first try drawing some stuff (but it feels way too hacky)

[feral hedge]

?render theme=light

#let ldiv(num, den) = {
  let num = $num$
  let den = $den$

  let num-shift = -0.2em
  let stack-spacing = 0.2em
  let line-thickness = 0.5pt
  let line-offset = 0.1em
  let length-of-ends = 0.2em

  let type-of-turn = "square" // try "square", "circle" or "none"

  let turn = if type-of-turn == "square" {
    square(fill: black, stroke: none, size: line-thickness)
  } else if type-of-turn == "circle" {
    circle(fill: black, stroke: none, radius: line-thickness / 2)
  } else if type-of-turn not in ("none", none) { panic("Unexpected type of end: " + type-of-turn) }
  
  stack(spacing: stack-spacing, 
    move(dx: num-shift, num), 
    style(styles => {
      let num-width = measure(num, styles).width
      let den-width = measure(den, styles).width
      let width = calc.max(num-width, den-width)
      
      place(
        dx: -width / 2, dy: line-offset,
        line(stroke: line-thickness, length: width)
      )
      
      place(
        dx: -width / 2, dy: line-offset,
        line(stroke: line-thickness, length: length-of-ends, angle: 90deg)
      )
      
      place(
        dx: width / 2, dy: line-offset,
        line(stroke: line-thickness, length: length-of-ends, angle: -90deg)
      )
  
      place(
        dx: -width / 2 - line-thickness / 2,
        dy: line-offset - line-thickness / 2,
        turn,
      )
      place(
        dx: width / 2 - line-thickness / 2,
        dy: line-offset - line-thickness / 2,
        turn,
      )
    }),
    den
  )
}

$ ldiv(a - b, a) $
$ (a - b) / a $

[lament perch]

?render theme=light ```$#box(
height: 5pt,
width: 10pt,
{
$1$
path(
(0%, -3pt),
(0%, -7pt),
(100%, -7pt),
(100%, -11pt),
)
set align(right)
pad(top: -14pt, $2$)
}
)$

🔥```

[feral hedge]

or not

[simple vault]

I get what you're saying, but I can't say I'm a fan.

[feral hedge]

wait path exists

I forgor

[lament perch]

I'm here for you

wait a second!

AAAAAA

ok I'm back, here you go: https://typst.app/docs/reference/visualize/path/

[feral hedge]

jesus, what just happened?

[lament perch]

I got lost for a second

[lament perch]

I tried to do your solution with path, but I think it removed the "circle" end option. Not sure where / if I got the spacing wrong somewhere

?render theme=light ```#let ldiv(num, den) = {
let num = $num$
let den = $den$

let num-shift = -0.2em
let stack-spacing = 0.2em
let line-thickness = 0.5pt
let line-offset = 0.1em
let length-of-ends = 0.2em

let type-of-turn = "square" // try "square", "circle" or "none"

let turn = if type-of-turn == "square" {
square(fill: black, stroke: none, size: line-thickness)
} else if type-of-turn == "circle" {
circle(fill: black, stroke: none, radius: line-thickness / 2)
} else if type-of-turn not in ("none", none) { panic("Unexpected type of end: " + type-of-turn) }

stack(spacing: stack-spacing,
move(dx: num-shift, num),
style(styles => {
let num-width = measure(num, styles).width
let den-width = measure(den, styles).width
let width = calc.max(num-width, den-width)

  place(
    dx: -width / 2, dy: line-offset,
    path(
      stroke: line-thickness,
      (0em, length-of-ends),
      (0em, 0em),
      (width, 0em),
      (width, -length-of-ends)
    )
  )
}),
den

)
}

$ ldiv(a - b, a) $
$ (a - b) / a $```

[feral hedge]

I just eyeballed the spacing anyway, so it does not matter. I also noticed that block math looks slightly nicer and does not require weird offsets for some reason

?render theme=light

#let ldiv(num, den) = {
  let num = $ num $
  let den = $ den $

  let num-shift = -0.1em
  let stack-spacing = 0.4em
  let line-thickness = 0.5pt
  let length-of-ends = 0.2em
  
  stack(spacing: stack-spacing, 
    move(dx: num-shift, num), 
    style(styles => {
      let num-width = measure(num, styles).width
      let den-width = measure(den, styles).width
      let width = calc.max(num-width, den-width)

      place(
        dx: -width / 2,
        path(
          stroke: line-thickness,
          (0em, length-of-ends),
          (0em, 0em),
          (width, 0em),
          (width, -length-of-ends)
        )
      )
    }),
    den
  )
}

$ ldiv(a - b, a) $
$ (a - b) / a $

[lament perch]

interesting. this is also the first time I see stack, move, place, and dashes-in-variable names

[feral hedge]

kebab-case is actually a default naming convention I believe

I still use snake_case sometimes though because that's what I'm used too, hopefully there are no hard restrictions

but yeah, default methods like string.starts-with are kebab-case

[restive jay]

quick, make a package