• @SpaceNoodle
    link
    English
    1198 months ago

    It’s a dynamically-sized list of objects of the same type stored contiguously in memory.

      • @Fosheze
        link
        English
        81
        edit-2
        8 months ago

        It’s a dynamically-sized list of objects of the same type stored contiguously in memory.

        dynamically-sized: The size of it can change as needed.

        list: It stores multiple things together.

        object: A bit of programmer defined data.

        of the same type: all the objects in the list are defined the same way

        stored contigiously in memory: if you think of memory as a bookshelf then all the objects on the list would be stored right next to each other on the bookshelf rather than spread across the bookshelf.

        • @kbotc
          link
          English
          158 months ago

          Dynamically sized but stored contiguously makes the systems performance engineer in me weep. If the lists get big, the kernel is going to do so much churn.

          • @[email protected]
            link
            fedilink
            English
            158 months ago

            Contiguous storage is very fast in terms of iteration though often offsetting the cost of allocation

            • @[email protected]
              link
              fedilink
              English
              78 months ago

              Modern CPUs are also extremely efficient at dealing with contiguous data structures. Branch prediction and caching get to shine on them.

              Avoiding memory access or helping CPU access it all upfront switches physical domain of computation.

          • :3 3: :3 3: :3 3: :3
            link
            fedilink
            English
            7
            edit-2
            8 months ago

            Which is why you should:

            1. Preallocate the vector if you can guesstimate the size
            2. Use a vector library that won’t reallocate the entire vector on every single addition (like Rust, whose Vec doubles in size every time it runs out of space)

            Memory is fairly cheap. Allocation time not so much.

          • @yetiftw
            link
            English
            48 months ago

            matlab likes to pick the smallest available spot in memory to store a list, so for loops that increase the size of a matrix it’s recommended to preallocate the space using a matrix full of zeros!

          • @tamal3
            link
            English
            28 months ago

            Is that churn or chum? (RN or M)

      • @SpaceNoodle
        link
        English
        38 months ago

        Many things like each other lined up in a row, and you can take some away or put more in.

      • @[email protected]
        link
        fedilink
        English
        68 months ago

        This is such an understated but useful description in this context. It’s also how I understood algebra for applied matrix computation.

        • @[email protected]
          link
          fedilink
          English
          4
          edit-2
          8 months ago

          I was just coming down from THC when I wrote this, so I’m extra jazzed you liked it. 😁

          Edit: also, love the username.

      • Gnome Kat
        link
        fedilink
        English
        48 months ago

        Its the algebraic properties that are important, not all vectors are n-tuples, eg the set of polynomials of degree less than n.

        You need a basis to coordinate a vector, you can work with vectors without doing that and just deal with the algebraic properties. The coordinate representation is dependent on the basis chosen and isn’t fundamental to the vector. So calling them n-tuples isn’t technically correct.

        You can turn them into a set of coordinates if you have a basis, but the fact that you can do that is because of the algebraic properties so it’s those properties which define what a vector is.

        • @[email protected]
          link
          fedilink
          English
          0
          edit-2
          8 months ago

          I think a better example to show how vectors don’t necessarily need to be what people conceptualize as n-tuples would have been the real numbers. (Of course, these can be considered 1-tuples, but the same can be said of any arbitrary set element that is not itself a tuple with more entries.) A cooler example would have been R[x] (the ring of real-valued polynomials of a single variable) especially since an isomorphic ring using n-tuples would be a more cumbersome representation of the algebra.

    • @conquer4
      link
      English
      18 months ago

      So an ArrayList?

      • unalivejoy
        link
        fedilink
        English
        10
        edit-2
        8 months ago

        No. ArrayList is thread safe and implements the collections API. Vector doesn’t. Though if you’re using Java, there’s almost no instance where you would want to use a Vector instead of ArrayList.

          • unalivejoy
            link
            fedilink
            English
            18 months ago

            Thread safe as in it raises an exception instead of breaking your list.

            • @[email protected]
              link
              fedilink
              English
              18 months ago

              Only if one thread modifies it while another one is iterating over it, if two threads try to modify the list at once there isn’t any kind of synchronization and it really could break your list.

              • unalivejoy
                link
                fedilink
                English
                18 months ago

                For everything else, there’s Collections.synchronizedList(new ArrayList<>())